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/15_puzzle_solver | 15 puzzle solver | Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.
For this task you will be using the following puzzle:
15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
The output must show the moves' directions, like so: left, left, left, down, right... and so on.
There are two solutions, of fifty-two moves:
rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd
rrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd
see: Pretty Print of Optimal Solution
Finding either one, or both is an acceptable result.
Extra credit.
Solve the following problem:
0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1
Related Task
15 puzzle game
A* search algorithm
| #C.2B.2B | C++ |
// Solve Random 15 Puzzles : Nigel Galloway - October 18th., 2017
class fifteenSolver{
const int Nr[16]{3,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3}, Nc[16]{3,0,1,2,3,0,1,2,3,0,1,2,3,0,1,2};
int n{},_n{}, N0[100]{},N3[100]{},N4[100]{};
unsigned long N2[100]{};
const bool fY(){
if (N4[n]<_n) return fN();
if (N2[n]==0x123456789abcdef0) {std::cout<<"Solution found in "<<n<<" moves :"; for (int g{1};g<=n;++g) std::cout<<(char)N3[g]; std::cout<<std::endl; return true;};
if (N4[n]==_n) return fN(); else return false;
}
const bool fN(){
if (N3[n]!='u' && N0[n]/4<3){fI(); ++n; if (fY()) return true; --n;}
if (N3[n]!='d' && N0[n]/4>0){fG(); ++n; if (fY()) return true; --n;}
if (N3[n]!='l' && N0[n]%4<3){fE(); ++n; if (fY()) return true; --n;}
if (N3[n]!='r' && N0[n]%4>0){fL(); ++n; if (fY()) return true; --n;}
return false;
}
void fI(){
const int g = (11-N0[n])*4;
const unsigned long a = N2[n]&((unsigned long)15<<g);
N0[n+1]=N0[n]+4; N2[n+1]=N2[n]-a+(a<<16); N3[n+1]='d'; N4[n+1]=N4[n]+(Nr[a>>g]<=N0[n]/4?0:1);
}
void fG(){
const int g = (19-N0[n])*4;
const unsigned long a = N2[n]&((unsigned long)15<<g);
N0[n+1]=N0[n]-4; N2[n+1]=N2[n]-a+(a>>16); N3[n+1]='u'; N4[n+1]=N4[n]+(Nr[a>>g]>=N0[n]/4?0:1);
}
void fE(){
const int g = (14-N0[n])*4;
const unsigned long a = N2[n]&((unsigned long)15<<g);
N0[n+1]=N0[n]+1; N2[n+1]=N2[n]-a+(a<<4); N3[n+1]='r'; N4[n+1]=N4[n]+(Nc[a>>g]<=N0[n]%4?0:1);
}
void fL(){
const int g = (16-N0[n])*4;
const unsigned long a = N2[n]&((unsigned long)15<<g);
N0[n+1]=N0[n]-1; N2[n+1]=N2[n]-a+(a>>4); N3[n+1]='l'; N4[n+1]=N4[n]+(Nc[a>>g]>=N0[n]%4?0:1);
}
public:
fifteenSolver(int n, unsigned long g){N0[0]=n; N2[0]=g;}
void Solve(){for(;not fY();++_n);}
};
|
http://rosettacode.org/wiki/99_bottles_of_beer | 99 bottles of beer | Task
Display the complete lyrics for the song: 99 Bottles of Beer on the Wall.
The beer song
The lyrics follow this form:
99 bottles of beer on the wall
99 bottles of beer
Take one down, pass it around
98 bottles of beer on the wall
98 bottles of beer on the wall
98 bottles of beer
Take one down, pass it around
97 bottles of beer on the wall
... and so on, until reaching 0 (zero).
Grammatical support for 1 bottle of beer is optional.
As with any puzzle, try to do it in as creative/concise/comical a way
as possible (simple, obvious solutions allowed, too).
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
See also
http://99-bottles-of-beer.net/
Category:99_Bottles_of_Beer
Category:Programming language families
Wikipedia 99 bottles of beer
| #ALGOL-M | ALGOL-M |
BEGIN
COMMENT PRINT LYRICS TO "99 BOTTLES OF BEER ON THE WALL";
STRING FUNCTION BOTTLE(N); % GIVE CORRECT GRAMMATICAL FORM %
INTEGER N;
BEGIN
IF N = 1 THEN
BOTTLE := " BOTTLE"
ELSE
BOTTLE := " BOTTLES";
END;
INTEGER N;
N := 99;
WHILE N > 0 DO
BEGIN
WRITE(N, BOTTLE(N), " OF BEER ON THE WALL,");
WRITEON(N, BOTTLE(N), " OF BEER");
WRITE("TAKE ONE DOWN AND PASS IT AROUND, ");
N := N - 1;
IF N = 0 THEN
WRITEON("NO MORE")
ELSE
WRITEON(N);
WRITEON(BOTTLE(N), " OF BEER ON THE WALL");
WRITE(" "); % BLANK LINE BETWEEN STANZAS %
END;
WRITE("THANKS FOR SINGING ALONG!");
END
|
http://rosettacode.org/wiki/24_game | 24 game | The 24 Game tests one's mental arithmetic.
Task
Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
The goal is for the player to enter an expression that (numerically) evaluates to 24.
Only the following operators/functions are allowed: multiplication, division, addition, subtraction
Division should use floating point or rational arithmetic, etc, to preserve remainders.
Brackets are allowed, if using an infix expression evaluator.
Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
The order of the digits when given does not have to be preserved.
Notes
The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
The task is not for the program to generate the expression, or test whether an expression is even possible.
Related tasks
24 game/Solve
Reference
The 24 Game on h2g2.
| #Common_Lisp | Common Lisp | (define-condition choose-digits () ())
(define-condition bad-equation (error) ())
(defun 24-game ()
(let (chosen-digits)
(labels ((prompt ()
(format t "Chosen digits: ~{~D~^, ~}~%~
Enter expression (or `bye' to quit, `!' to choose new digits): "
chosen-digits)
(read))
(lose () (error 'bad-equation))
(choose () (setf chosen-digits (loop repeat 4 collecting (1+ (random 9)))))
(check (e)
(typecase e
((eql bye) (return-from 24-game))
((eql !) (signal 'choose-digits))
(atom (lose))
(cons (check-sub (car e) (check-sub (cdr e) chosen-digits)) e)))
(check-sub (sub allowed-digits)
(typecase sub
((member nil + - * /) allowed-digits)
(integer
(if (member sub allowed-digits)
(remove sub allowed-digits :count 1)
(lose)))
(cons (check-sub (car sub) (check-sub (cdr sub) allowed-digits)))
(t (lose))))
(win ()
(format t "You win.~%")
(return-from 24-game)))
(choose)
(loop
(handler-case
(if (= 24 (eval (check (prompt)))) (win) (lose))
(error () (format t "Bad equation, try again.~%"))
(choose-digits () (choose))))))) |
http://rosettacode.org/wiki/9_billion_names_of_God_the_integer | 9 billion names of God the integer | This task is a variation of the short story by Arthur C. Clarke.
(Solvers should be aware of the consequences of completing this task.)
In detail, to specify what is meant by a “name”:
The integer 1 has 1 name “1”.
The integer 2 has 2 names “1+1”, and “2”.
The integer 3 has 3 names “1+1+1”, “2+1”, and “3”.
The integer 4 has 5 names “1+1+1+1”, “2+1+1”, “2+2”, “3+1”, “4”.
The integer 5 has 7 names “1+1+1+1+1”, “2+1+1+1”, “2+2+1”, “3+1+1”, “3+2”, “4+1”, “5”.
Task
Display the first 25 rows of a number triangle which begins:
1
1 1
1 1 1
1 2 1 1
1 2 2 1 1
1 3 3 2 1 1
Where row
n
{\displaystyle n}
corresponds to integer
n
{\displaystyle n}
, and each column
C
{\displaystyle C}
in row
m
{\displaystyle m}
from left to right corresponds to the number of names beginning with
C
{\displaystyle C}
.
A function
G
(
n
)
{\displaystyle G(n)}
should return the sum of the
n
{\displaystyle n}
-th row.
Demonstrate this function by displaying:
G
(
23
)
{\displaystyle G(23)}
,
G
(
123
)
{\displaystyle G(123)}
,
G
(
1234
)
{\displaystyle G(1234)}
, and
G
(
12345
)
{\displaystyle G(12345)}
.
Optionally note that the sum of the
n
{\displaystyle n}
-th row
P
(
n
)
{\displaystyle P(n)}
is the integer partition function.
Demonstrate this is equivalent to
G
(
n
)
{\displaystyle G(n)}
by displaying:
P
(
23
)
{\displaystyle P(23)}
,
P
(
123
)
{\displaystyle P(123)}
,
P
(
1234
)
{\displaystyle P(1234)}
, and
P
(
12345
)
{\displaystyle P(12345)}
.
Extra credit
If your environment is able, plot
P
(
n
)
{\displaystyle P(n)}
against
n
{\displaystyle n}
for
n
=
1
…
999
{\displaystyle n=1\ldots 999}
.
Related tasks
Partition function P
| #VBA | VBA | Public Sub nine_billion_names()
Dim p(25, 25) As Long
p(1, 1) = 1
For i = 2 To 25
For j = 1 To i
p(i, j) = p(i - 1, j - 1) + p(i - j, j)
Next j
Next i
For i = 1 To 25
Debug.Print String$(50 - 2 * i, " ");
For j = 1 To i
Debug.Print String$(4 - Len(CStr(p(i, j))), " ") & p(i, j);
Next j
Debug.Print
Next i
End Sub |
http://rosettacode.org/wiki/9_billion_names_of_God_the_integer | 9 billion names of God the integer | This task is a variation of the short story by Arthur C. Clarke.
(Solvers should be aware of the consequences of completing this task.)
In detail, to specify what is meant by a “name”:
The integer 1 has 1 name “1”.
The integer 2 has 2 names “1+1”, and “2”.
The integer 3 has 3 names “1+1+1”, “2+1”, and “3”.
The integer 4 has 5 names “1+1+1+1”, “2+1+1”, “2+2”, “3+1”, “4”.
The integer 5 has 7 names “1+1+1+1+1”, “2+1+1+1”, “2+2+1”, “3+1+1”, “3+2”, “4+1”, “5”.
Task
Display the first 25 rows of a number triangle which begins:
1
1 1
1 1 1
1 2 1 1
1 2 2 1 1
1 3 3 2 1 1
Where row
n
{\displaystyle n}
corresponds to integer
n
{\displaystyle n}
, and each column
C
{\displaystyle C}
in row
m
{\displaystyle m}
from left to right corresponds to the number of names beginning with
C
{\displaystyle C}
.
A function
G
(
n
)
{\displaystyle G(n)}
should return the sum of the
n
{\displaystyle n}
-th row.
Demonstrate this function by displaying:
G
(
23
)
{\displaystyle G(23)}
,
G
(
123
)
{\displaystyle G(123)}
,
G
(
1234
)
{\displaystyle G(1234)}
, and
G
(
12345
)
{\displaystyle G(12345)}
.
Optionally note that the sum of the
n
{\displaystyle n}
-th row
P
(
n
)
{\displaystyle P(n)}
is the integer partition function.
Demonstrate this is equivalent to
G
(
n
)
{\displaystyle G(n)}
by displaying:
P
(
23
)
{\displaystyle P(23)}
,
P
(
123
)
{\displaystyle P(123)}
,
P
(
1234
)
{\displaystyle P(1234)}
, and
P
(
12345
)
{\displaystyle P(12345)}
.
Extra credit
If your environment is able, plot
P
(
n
)
{\displaystyle P(n)}
against
n
{\displaystyle n}
for
n
=
1
…
999
{\displaystyle n=1\ldots 999}
.
Related tasks
Partition function P
| #Vlang | Vlang | import math.big
fn int_min(a int, b int) int {
if a < b {
return a
} else {
return b
}
}
fn cumu (mut cache [][]big.Integer, n int) []big.Integer {
for y := cache.len; y <= n; y++ {
mut row := [big.zero_int]
for x := 1; x <= y; x++ {
cache_value := cache[y-x][int_min(x, y-x)]
row << row[row.len-1] + cache_value
}
cache << row
}
return cache[n]
}
fn main() {
mut cache := [[big.one_int]]
row := fn[mut cache](n int) {
e := cumu(mut cache, n)
for i := 0; i < n; i++ {
print(" ${e[i+1]-e[i]} ")
}
println('')
}
println("rows:")
for x := 1; x < 11; x++ {
row(x)
}
println('')
println("sums:")
for num in [23, 123, 1234, 12345] {
r := cumu(mut cache, num)
println("$num ${r[r.len-1]}")
}
} |
http://rosettacode.org/wiki/A%2BB | A+B | A+B ─── a classic problem in programming contests, it's given so contestants can gain familiarity with the online judging system being used.
Task
Given two integers, A and B.
Their sum needs to be calculated.
Input data
Two integers are written in the input stream, separated by space(s):
(
−
1000
≤
A
,
B
≤
+
1000
)
{\displaystyle (-1000\leq A,B\leq +1000)}
Output data
The required output is one integer: the sum of A and B.
Example
input
output
2 2
4
3 2
5
| #C.23 | C# | using System;
using System.Linq;
class Program
{
static void Main()
{
Console.WriteLine(Console.ReadLine().Split().Select(int.Parse).Sum());
}
} |
http://rosettacode.org/wiki/Ackermann_function | Ackermann function | The Ackermann function is a classic example of a recursive function, notable especially because it is not a primitive recursive function. It grows very quickly in value, as does the size of its call tree.
The Ackermann function is usually defined as follows:
A
(
m
,
n
)
=
{
n
+
1
if
m
=
0
A
(
m
−
1
,
1
)
if
m
>
0
and
n
=
0
A
(
m
−
1
,
A
(
m
,
n
−
1
)
)
if
m
>
0
and
n
>
0.
{\displaystyle A(m,n)={\begin{cases}n+1&{\mbox{if }}m=0\\A(m-1,1)&{\mbox{if }}m>0{\mbox{ and }}n=0\\A(m-1,A(m,n-1))&{\mbox{if }}m>0{\mbox{ and }}n>0.\end{cases}}}
Its arguments are never negative and it always terminates.
Task
Write a function which returns the value of
A
(
m
,
n
)
{\displaystyle A(m,n)}
. Arbitrary precision is preferred (since the function grows so quickly), but not required.
See also
Conway chained arrow notation for the Ackermann function.
| #TorqueScript | TorqueScript | function ackermann(%m,%n)
{
if(%m==0)
return %n+1;
if(%m>0&&%n==0)
return ackermann(%m-1,1);
if(%m>0&&%n>0)
return ackermann(%m-1,ackermann(%m,%n-1));
} |
http://rosettacode.org/wiki/ABC_problem | ABC problem | ABC problem
You are encouraged to solve this task according to the task description, using any language you may know.
You are given a collection of ABC blocks (maybe like the ones you had when you were a kid).
There are twenty blocks with two letters on each block.
A complete alphabet is guaranteed amongst all sides of the blocks.
The sample collection of blocks:
(B O)
(X K)
(D Q)
(C P)
(N A)
(G T)
(R E)
(T G)
(Q D)
(F S)
(J W)
(H U)
(V I)
(A N)
(O B)
(E R)
(F S)
(L Y)
(P C)
(Z M)
Task
Write a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.
The rules are simple:
Once a letter on a block is used that block cannot be used again
The function should be case-insensitive
Show the output on this page for the following 7 words in the following example
Example
>>> can_make_word("A")
True
>>> can_make_word("BARK")
True
>>> can_make_word("BOOK")
False
>>> can_make_word("TREAT")
True
>>> can_make_word("COMMON")
False
>>> can_make_word("SQUAD")
True
>>> can_make_word("CONFUSE")
True
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
| #F.23 | F# | let rec spell_word_with blocks w =
let rec look_for_right_candidate candidates noCandidates c rest =
match candidates with
| [] -> false
| c0::cc ->
if spell_word_with (cc@noCandidates) rest then true
else look_for_right_candidate cc (c0::noCandidates) c rest
match w with
| "" -> true
| w ->
let c = w.[0]
let rest = w.Substring(1)
let (candidates, noCandidates) = List.partition(fun (c1,c2) -> c = c1 || c = c2) blocks
look_for_right_candidate candidates noCandidates c rest
[<EntryPoint>]
let main argv =
let default_blocks = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM"
let blocks =
(if argv.Length > 0 then argv.[0] else default_blocks).Split()
|> List.ofArray
|> List.map(fun s -> s.ToUpper())
|> List.map(fun s2 -> s2.[0], s2.[1])
let words =
(if argv.Length > 0 then List.ofArray(argv).Tail else [])
|> List.map(fun s -> s.ToUpper())
List.iter (fun w -> printfn "Using the blocks we can make the word '%s': %b" w (spell_word_with blocks w)) words
0 |
http://rosettacode.org/wiki/100_prisoners | 100 prisoners |
The Problem
100 prisoners are individually numbered 1 to 100
A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.
Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.
Prisoners start outside the room
They can decide some strategy before any enter the room.
Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.
A prisoner can open no more than 50 drawers.
A prisoner tries to find his own number.
A prisoner finding his own number is then held apart from the others.
If all 100 prisoners find their own numbers then they will all be pardoned. If any don't then all sentences stand.
The task
Simulate several thousand instances of the game where the prisoners randomly open drawers
Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:
First opening the drawer whose outside number is his prisoner number.
If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).
Show and compare the computed probabilities of success for the two strategies, here, on this page.
References
The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).
wp:100 prisoners problem
100 Prisoners Escape Puzzle DataGenetics.
Random permutation statistics#One hundred prisoners on Wikipedia.
| #Common_Lisp | Common Lisp |
(defparameter *samples* 10000)
(defparameter *prisoners* 100)
(defparameter *max-guesses* 50)
(defun range (n)
"Returns a list from 0 to N."
(loop
for i below n
collect i))
(defun nshuffle (list)
"Returns a shuffled LIST."
(loop
for i from (length list) downto 2
do (rotatef (nth (random i) list)
(nth (1- i) list)))
list)
(defun build-drawers ()
"Returns a list of shuffled drawers."
(nshuffle (range *prisoners*)))
(defun strategy-1 (drawers p)
"Returns T if P is found in DRAWERS under *MAX-GUESSES* using a random strategy."
(loop
for i below *max-guesses*
thereis (= p (nth (random *prisoners*) drawers))))
(defun strategy-2 (drawers p)
"Returns T if P is found in DRAWERS under *MAX-GUESSES* using an optimal strategy."
(loop
for i below *max-guesses*
for j = p then (nth j drawers)
thereis (= p (nth j drawers))))
(defun 100-prisoners-problem (strategy &aux (drawers (build-drawers)))
"Returns T if all prisoners find their number using the given STRATEGY."
(every (lambda (e) (eql T e))
(mapcar (lambda (p) (funcall strategy drawers p)) (range *prisoners*))))
(defun sampling (strategy)
(loop
repeat *samples*
for result = (100-prisoners-problem strategy)
count result))
(defun compare-strategies ()
(format t "Using a random strategy in ~4,2F % of the cases the prisoners are free.~%" (* (/ (sampling #'strategy-1) *samples*) 100))
(format t "Using an optimal strategy in ~4,2F % of the cases the prisoners are free.~%" (* (/ (sampling #'strategy-2) *samples*) 100)))
|
http://rosettacode.org/wiki/Abundant_odd_numbers | Abundant odd numbers | An Abundant number is a number n for which the sum of divisors σ(n) > 2n,
or, equivalently, the sum of proper divisors (or aliquot sum) s(n) > n.
E.G.
12 is abundant, it has the proper divisors 1,2,3,4 & 6 which sum to 16 ( > 12 or n);
or alternately, has the sigma sum of 1,2,3,4,6 & 12 which sum to 28 ( > 24 or 2n).
Abundant numbers are common, though even abundant numbers seem to be much more common than odd abundant numbers.
To make things more interesting, this task is specifically about finding odd abundant numbers.
Task
Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.
Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.
Find and display here: the first abundant odd number greater than one billion (109) and either its proper divisor sum or sigma sum.
References
OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)
American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)
| #Smalltalk | Smalltalk | divisors :=
[:nr |
|divs|
divs := Set with:1.
"no need to check even factors; we are only looking for odd nrs"
3 to:(nr integerSqrt) by:2 do:[:d | nr % d = 0 ifTrue:[divs add:d; add:(nr / d)]].
divs.
].
isAbundant := [:nr | (divisors value:nr) sum > nr].
"from set of abdundant numbers >= minNr, print nMinPrint-th to nMaxPrint-th"
printNAbundant :=
[:minNr :nMinPrint :nMaxPrint |
|count divs|
count := 0.
minNr to:Infinity positive doWithExit:[:nr :exit |
(nr odd and:[isAbundant value:nr]) ifTrue:[
count := count + 1.
count >= nMinPrint ifTrue:[
divs := divisors value:nr.
Transcript
show:nr; show:' -> '; show:divs asArray sorted;
show:' sum = '; showCR:divs sum.
].
count >= nMaxPrint ifTrue: exit
]
]
].
Transcript showCR:'first 25 odd abundant numbers:'.
"from set of abdundant numbers >= 3, print 1st to 25th"
printNAbundant value:3 value:1 value:25.
Transcript cr; showCR:'first odd abundant number above 1000000000:'.
"from set of abdundant numbers >= 1000000000, print 1st to 1st"
printNAbundant value:1000000000 value:1 value:1.
Transcript cr; showCR:'first odd abundant number above 1000000000000:'.
"from set of abdundant numbers >= 1000000000, print 1st to 1st"
printNAbundant value:1000000000000 value:1 value:1.
Transcript cr; showCR:'the 1000th odd abundant number is:'.
"from set of abdundant numbers>= 3, print 1000th to 1000th"
printNAbundant value:3 value:1000 value:1000. |
http://rosettacode.org/wiki/21_game | 21 game | 21 game
You are encouraged to solve this task according to the task description, using any language you may know.
21 is a two player game, the game is played by choosing
a number (1, 2, or 3) to be added to the running total.
The game is won by the player whose chosen number causes the running total
to reach exactly 21.
The running total starts at zero.
One player will be the computer.
Players alternate supplying a number to be added to the running total.
Task
Write a computer program that will:
do the prompting (or provide a button menu),
check for errors and display appropriate error messages,
do the additions (add a chosen number to the running total),
display the running total,
provide a mechanism for the player to quit/exit/halt/stop/close the program,
issue a notification when there is a winner, and
determine who goes first (maybe a random or user choice, or can be specified when the game begins).
| #PHP | PHP | <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="keywords" content="Game 21">
<meta name="description" content="
21 is a two player game, the game is played by choosing a number
(1, 2, or 3) to be added to the running total. The game is won by
the player whose chosen number causes the running total to reach
exactly 21. The running total starts at zero.
">
<!--DCMI metadata (Dublin Core Metadata Initiative)-->
<meta name="dc.publisher" content="Rosseta Code">
<meta name="dc.date" content="2020-07-31">
<meta name="dc.created" content="2020-07-31">
<meta name="dc.modified" content="2020-08-01">
<title>
21 Game
</title>
<!-- Remove the line below in the final/production version. -->
<meta http-equiv="cache-control" content="no-cache">
<style>
.ui div { width: 50%; display: inline-flex; justify-content: flex-end; }
div.total { margin-bottom: 1ch; }
label { padding-right: 1ch; }
button + button { margin-left: 1em; }
</style>
</head>
<body>
<h1>
21 Game in PHP 7
</h1>
<p>
21 is a two player game, the game is played by choosing a number
(1, 2, or 3) to be added to the running total. The game is won by
the player whose chosen number causes the running total to reach
exactly 21. The running total starts at zero.
</p>
<?php
const GOAL = 21;
const PLAYERS = array('AI', 'human');
function best_move($n)
{
for ($i = 1; $i <= 3; $i++)
if ($n + $i == GOAL)
return $i;
for ($i = 1; $i <= 3; $i++)
if (($n + $i - 1) % 4 == 0)
return $i;
return 1;
}
if (isset($_GET['reset']) || !isset($_GET['total']))
{
$first = PLAYERS[rand(0, 1)];
$total = 0;
$human = 0;
$ai = 0;
$message = '';
if ($first == 'AI')
{
$move = best_move($total);
$ai = $move;
$total = $total + $move;
}
}
else
{
$first = $_GET['first'];
$total = $_GET['total'];
$human = $_GET['human'];
$ai = $_GET['ai'];
$message = $_GET['message'];
}
if (isset($_GET['move']))
{
$move = (int)$_GET['move'];
$human = $move;
$total = $total + $move;
if ($total == GOAL)
$message = 'The winner is human.';
else
{
$move = best_move($total);
$ai = $move;
$total = $total + $move;
if ($total == GOAL)
$message = 'The winner is AI.';
}
}
$state = array();
for ($i = 1; $i <= 3; $i++)
$state[$i] = $total + $i > GOAL ? 'disabled' : '';
echo <<< END
<p>
The first player is $first.
Use buttons to play.
</p>
<form class="ui">
<div>
<input type='hidden' id='first' name='first' value='$first'>
<input type='hidden' name='message' value='$message'>
</div>
<div class='total'>
<label for='human'>human last choice:</label>
<input type='text' name='human' readonly value='$human'>
</div>
<div class='total'>
<label for='AI'>AI last choice:</label>
<input type='text' name='ai' readonly value='$ai'>
</div>
<div class='total'>
<label for='runningTotalText'>running total:</label>
<input type='text' name='total' readonly value='$total'>
</div>
<div class='buttons'>
<button type='submit' name='move' value='1' {$state[1]}> one </button>
<button type='submit' name='move' value='2' {$state[2]}> two </button>
<button type='submit' name='move' value='3' {$state[3]}> three </button>
<button type='submit' name='reset' value='reset'> reset </button>
</div>
</form>
<p>
$message
</p>
END
?>
</body> |
http://rosettacode.org/wiki/24_game/Solve | 24 game/Solve | task
Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the 24 game.
Show examples of solutions generated by the program.
Related task
Arithmetic Evaluator
| #Factor | Factor | USING: continuations grouping io kernel math math.combinatorics
prettyprint quotations random sequences sequences.deep ;
IN: rosetta-code.24-game
: 4digits ( -- seq ) 4 9 random-integers [ 1 + ] map ;
: expressions ( digits -- exprs )
all-permutations [ [ + - * / ] 3 selections
[ append ] with map ] map flatten 7 group ;
: 24= ( exprs -- )
>quotation dup call( -- x ) 24 = [ . ] [ drop ] if ;
: 24-game ( -- )
4digits dup "The numbers: " write . "The solutions: "
print expressions [ [ 24= ] [ 2drop ] recover ] each ;
24-game |
http://rosettacode.org/wiki/15_puzzle_game | 15 puzzle game |
Task
Implement the Fifteen Puzzle Game.
The 15-puzzle is also known as:
Fifteen Puzzle
Gem Puzzle
Boss Puzzle
Game of Fifteen
Mystic Square
14-15 Puzzle
and some others.
Related Tasks
15 Puzzle Solver
16 Puzzle Game
| #11l | 11l | T Puzzle
position = 0
[Int = String] items
F main_frame()
V& d = .items
print(‘+-----+-----+-----+-----+’)
print(‘|#.|#.|#.|#.|’.format(d[1], d[2], d[3], d[4]))
print(‘+-----+-----+-----+-----+’)
print(‘|#.|#.|#.|#.|’.format(d[5], d[6], d[7], d[8]))
print(‘+-----+-----+-----+-----+’)
print(‘|#.|#.|#.|#.|’.format(d[9], d[10], d[11], d[12]))
print(‘+-----+-----+-----+-----+’)
print(‘|#.|#.|#.|#.|’.format(d[13], d[14], d[15], d[16]))
print(‘+-----+-----+-----+-----+’)
F format(=ch)
ch = ch.trim(‘ ’)
I ch.len == 1
R ‘ ’ch‘ ’
E I ch.len == 2
R ‘ ’ch‘ ’
E
assert(ch.empty)
R ‘ ’
F change(=to)
V fro = .position
L(a, b) .items
I b == .format(String(to))
to = a
L.break
swap(&.items[fro], &.items[to])
.position = to
F build_board(difficulty)
L(i) 1..16
.items[i] = .format(String(i))
V tmp = 0
L(a, b) .items
I b == ‘ 16 ’
.items[a] = ‘ ’
tmp = a
L.break
.position = tmp
Int diff
I difficulty == 0
diff = 10
E I difficulty == 1
diff = 50
E
diff = 100
L 0 .< diff
V lst = .valid_moves()
[Int] lst1
L(j) lst
lst1.append(Int(j.trim(‘ ’)))
.change(lst1[random:(lst1.len)])
F valid_moves()
V pos = .position
I pos C [6, 7, 10, 11]
R [.items[pos - 4], .items[pos - 1], .items[pos + 1], .items[pos + 4]]
E I pos C [5, 9]
R [.items[pos - 4], .items[pos + 4], .items[pos + 1]]
E I pos C [8, 12]
R [.items[pos - 4], .items[pos + 4], .items[pos - 1]]
E I pos C [2, 3]
R [.items[pos - 1], .items[pos + 1], .items[pos + 4]]
E I pos C [14, 15]
R [.items[pos - 1], .items[pos + 1], .items[pos - 4]]
E I pos == 1
R [.items[pos + 1], .items[pos + 4]]
E I pos == 4
R [.items[pos - 1], .items[pos + 4]]
E I pos == 13
R [.items[pos + 1], .items[pos - 4]]
E
assert(pos == 16)
R [.items[pos - 1], .items[pos - 4]]
F game_over()
V flag = 0B
L(a, b) .items
I b != ‘ ’
I a == Int(b.trim(‘ ’))
flag = 1B
E
flag = 0B
R flag
V g = Puzzle()
g.build_board(Int(input("Enter the difficulty : 0 1 2\n2 => highest 0 => lowest\n")))
g.main_frame()
print(‘Enter 0 to exit’)
L
print("Hello user:\nTo change the position just enter the no. near it")
V lst = g.valid_moves()
[Int] lst1
L(i) lst
lst1.append(Int(i.trim(‘ ’)))
print(i.trim(‘ ’)" \t", end' ‘’)
print()
V x = Int(input())
I x == 0
L.break
E I x !C lst1
print(‘Wrong move’)
E
g.change(x)
g.main_frame()
I g.game_over()
print(‘You WON’)
L.break |
http://rosettacode.org/wiki/2048 | 2048 | Task
Implement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.
Rules of the game
The rules are that on each turn the player must choose a direction (up, down, left or right).
All tiles move as far as possible in that direction, some move more than others.
Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.
A move is valid when at least one tile can be moved, if only by combination.
A new tile with the value of 2 is spawned at the end of each turn at a randomly chosen empty square (if there is one).
Adding a new tile on a blank space. Most of the time, a new 2 is to be added, and occasionally (10% of the time), a 4.
To win, the player must create a tile with the number 2048.
The player loses if no valid moves are possible.
The name comes from the popular open-source implementation of this game mechanic, 2048.
Requirements
"Non-greedy" movement.
The tiles that were created by combining other tiles should not be combined again during the same turn (move).
That is to say, that moving the tile row of:
[2][2][2][2]
to the right should result in:
......[4][4]
and not:
.........[8]
"Move direction priority".
If more than one variant of combining is possible, move direction shall indicate which combination will take effect.
For example, moving the tile row of:
...[2][2][2]
to the right should result in:
......[2][4]
and not:
......[4][2]
Check for valid moves. The player shouldn't be able to skip their turn by trying a move that doesn't change the board.
Check for a win condition.
Check for a lose condition.
| #ARM_Assembly | ARM Assembly |
/* ARM assembly Raspberry PI */
/* program 2048.s */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
.equ STDIN, 0 @ Linux input console
.equ READ, 3 @ Linux syscall
.equ SIZE, 4
.equ TOTAL, 2048
.equ BUFFERSIZE, 80
.equ IOCTL, 0x36 @ Linux syscall
.equ SIGACTION, 0x43 @ Linux syscall
.equ SYSPOLL, 0xA8 @ Linux syscall
.equ TCGETS, 0x5401
.equ TCSETS, 0x5402
.equ ICANON, 2
.equ ECHO, 10
.equ POLLIN, 1
.equ SIGINT, 2 @ Issued if the user sends an interrupt signal (Ctrl + C)
.equ SIGQUIT, 3 @ Issued if the user sends a quit signal (Ctrl + D)
.equ SIGTERM, 15 @ Software termination signal (sent by kill by default)
.equ SIGTTOU, 22
/*******************************************/
/* Structures */
/********************************************/
/* structure termios see doc linux*/
.struct 0
term_c_iflag: @ input modes
.struct term_c_iflag + 4
term_c_oflag: @ output modes
.struct term_c_oflag + 4
term_c_cflag: @ control modes
.struct term_c_cflag + 4
term_c_lflag: @ local modes
.struct term_c_lflag + 4
term_c_cc: @ special characters
.struct term_c_cc + 20 @ see length if necessary
term_fin:
/* structure sigaction see doc linux */
.struct 0
sa_handler:
.struct sa_handler + 4
sa_mask:
.struct sa_mask + 4
sa_flags:
.struct sa_flags + 4
sa_sigaction:
.struct sa_sigaction + 4
sa_fin:
/* structure poll see doc linux */
.struct 0
poll_fd: @ File Descriptor
.struct poll_fd + 4
poll_events: @ events mask
.struct poll_events + 4
poll_revents: @ events returned
.struct poll_revents + 4
poll_fin:
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessOK: .asciz "Bravo !! You win. \n"
szMessNotOK: .asciz "You lost !! \n"
szMessNewGame: .asciz "New game (y/n) ? \n"
szMessErreur: .asciz "Error detected.\n"
szCarriageReturn: .asciz "\n"
//szMessMovePos: .asciz "\033[00;00H"
szMess0: .asciz " "
szMess2: .asciz " 2 "
szMess4: .asciz " 4 "
szMess8: .asciz " 8 "
szMess16: .asciz " 16 "
szMess32: .asciz " 32 "
szMess64: .asciz " 64 "
szMess128: .asciz " 128 "
szMess256: .asciz " 256 "
szMess512: .asciz " 512 "
szMess1024: .asciz " 1024 "
szMess2048: .asciz " 2048 "
szClear1: .byte 0x1B
.byte 'c' @ other console clear
.byte 0
szLineH: .asciz "-----------------------------\n"
szLineV: .asciz "|"
szLineVT: .asciz "| | | | |\n"
.align 4
iGraine: .int 123456
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
.align 4
sZoneConv: .skip 24
sBuffer: .skip BUFFERSIZE
iTbCase: .skip 4 * SIZE * SIZE
iEnd: .skip 4 @ 0 loop 1 = end loop
iTouche: .skip 4 @ value key pressed
stOldtio: .skip term_fin @ old terminal state
stCurtio: .skip term_fin @ current terminal state
stSigAction: .skip sa_fin @ area signal structure
stSigAction1: .skip sa_fin
stPoll1: .skip poll_fin @ area poll structure
stPoll2: .skip poll_fin
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
1: @ begin game loop
ldr r0,iAdrszClear1
bl affichageMess
bl razTable
2:
bl addDigit
cmp r0,#-1
beq 5f @ end game
bl displayGame
3:
bl readKey
cmp r0,#-1
beq 100f @ error or control-c
bl keyMove
cmp r0,#0
beq 3b @ no change -> loop
cmp r0,#2 @ last addition = 2048 ?
beq 4f
cmp r0,#-1 @ quit ?
bne 2b @ loop
b 10f
4: @ last addition = 2048
ldr r0,iAdrszMessOK
bl affichageMess
b 10f
5: @ display message no solution
ldr r0,iAdrszMessNotOK
bl affichageMess
10: @ display new game ?
ldr r0,iAdrszCarriageReturn
bl affichageMess
ldr r0,iAdrszMessNewGame
bl affichageMess
bl readKey
ldr r0,iAdriTouche
ldrb r0,[r0]
cmp r0,#'y'
beq 1b
cmp r0,#'Y'
beq 1b
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
iAdrszMessNotOK: .int szMessNotOK
iAdrszMessOK: .int szMessOK
iAdrszMessNewGame: .int szMessNewGame
iAdrsZoneConv: .int sZoneConv
iAdrszClear1: .int szClear1
/******************************************************************/
/* raz table cases */
/******************************************************************/
razTable:
push {r0-r2,lr} @ save registers
ldr r1,iAdriTbCase
mov r0,#0
mov r2,#0
1:
str r0,[r1,r2,lsl #2]
add r2,r2,#1
cmp r2,#SIZE * SIZE
blt 1b
100:
pop {r0-r2,lr} @ restaur registers
bx lr @return
/******************************************************************/
/* key move */
/******************************************************************/
/* r0 contains key value */
keyMove:
push {r1,lr} @ save registers
cmp r0,#0x42 @ down arrow
bne 1f
bl moveDown
b 100f
1:
cmp r0,#0x41 @ high arrow
bne 2f
bl moveUp
b 100f
2:
cmp r0,#0x43 @ right arrow
bne 3f
bl moveRight
b 100f
3:
cmp r0,#0x44 @ left arrow
bne 4f
bl moveLeft
b 100f
4:
ldr r0,iAdriTouche
ldrb r0,[r0]
cmp r0,#'q' @ quit game
bne 5f
mov r0,#-1
b 100f
5:
cmp r0,#'Q' @ quit game
bne 100f
mov r0,#-1
b 100f
100:
pop {r1,lr} @ restaur registers
bx lr @return
/******************************************************************/
/* move left */
/******************************************************************/
/* r0 return -1 if ok */
moveLeft:
push {r1-r10,lr} @ save registers
ldr r1,iAdriTbCase
mov r0,#0 @ top move Ok
mov r2,#0 @ line indice
1:
mov r6,#0 @ counter empty case
mov r7,#0 @ first digit
mov r10,#0 @ last digit to add
mov r3,#0 @ column indice
2:
lsl r5,r2,#2 @ change this if size <> 4
add r5,r5,r3 @ compute table indice
ldr r4,[r1,r5,lsl #2]
cmp r4,#0
addeq r6,r6,#1 @ positions vides
beq 5f
cmp r6,#0
beq 3f @ no empty left case
mov r8,#0
str r8,[r1,r5,lsl #2] @ raz digit
sub r5,r5,r6
str r4,[r1,r5,lsl #2] @ and store to left empty position
mov r0,#1 @ move Ok
//sub r6,r6,#1
3:
cmp r7,#0 @ first digit
beq 4f
cmp r10,r4 @ prec digit have to add
beq 4f
sub r8,r5,#1 @ prec digit
ldr r9,[r1,r8,lsl #2]
cmp r4,r9 @ equal ?
bne 4f
mov r10,r4 @ save digit
add r4,r4,r9 @ yes -> add
str r4,[r1,r8,lsl #2]
cmp r4,#TOTAL
moveq r0,#2
beq 100f
mov r4,#0
str r4,[r1,r5,lsl #2]
add r6,r6,#1 @ empty case + 1
mov r0,#1 @ move Ok
4:
add r7,r7,#1 @ no first digit
5: @ and loop
add r3,r3,#1
cmp r3,#SIZE
blt 2b
add r2,r2,#1
cmp r2,#SIZE
blt 1b
100:
pop {r1-r12,lr}
bx lr @ return
/******************************************************************/
/* move right */
/******************************************************************/
/* r0 return -1 if ok */
moveRight:
push {r1-r5,lr} @ save registers
ldr r1,iAdriTbCase
mov r0,#0
mov r2,#0
1:
mov r6,#0
mov r7,#0
mov r10,#0
mov r3,#SIZE-1
2:
lsl r5,r2,#2 @ change this if size <> 4
add r5,r5,r3
ldr r4,[r1,r5,lsl #2]
cmp r4,#0
addeq r6,r6,#1 @ positions vides
beq 5f
cmp r6,#0
beq 3f @ no empty right case
mov r0,#0
str r0,[r1,r5,lsl #2] @ raz digit
add r5,r5,r6
str r4,[r1,r5,lsl #2] @ and store to right empty position
mov r0,#1
3:
cmp r7,#0 @ first digit
beq 4f
add r8,r5,#1 @ next digit
ldr r9,[r1,r8,lsl #2]
cmp r4,r9 @ equal ?
bne 4f
cmp r10,r4
beq 4f
mov r10,r4
add r4,r4,r9 @ yes -> add
str r4,[r1,r8,lsl #2]
cmp r4,#TOTAL
moveq r0,#2
beq 100f
mov r4,#0
str r4,[r1,r5,lsl #2]
add r6,r6,#1 @ empty case + 1
mov r0,#1
4:
add r7,r7,#1 @ no first digit
5: @ and loop
sub r3,r3,#1
cmp r3,#0
bge 2b
add r2,r2,#1
cmp r2,#SIZE
blt 1b
100:
pop {r1-r5,lr}
bx lr @ return
/******************************************************************/
/* move down */
/******************************************************************/
/* r0 return -1 if ok */
moveDown:
push {r1-r5,lr} @ save registers
ldr r1,iAdriTbCase
mov r0,#0
mov r3,#0
1:
mov r6,#0
mov r7,#0
mov r10,#0
mov r2,#SIZE-1
2:
lsl r5,r2,#2 @ change this if size <> 4
add r5,r5,r3
ldr r4,[r1,r5,lsl #2]
cmp r4,#0
addeq r6,r6,#1 @ positions vides
beq 5f
cmp r6,#0
beq 3f @ no empty right case
mov r0,#0
str r0,[r1,r5,lsl #2] @ raz digit
lsl r0,r6,#2
add r5,r5,r0
str r4,[r1,r5,lsl #2] @ and store to right empty position
mov r0,#1
3:
cmp r7,#0 @ first digit
beq 4f
add r8,r5,#SIZE @ down digit
ldr r9,[r1,r8,lsl #2]
cmp r4,r9 @ equal ?
bne 4f
cmp r10,r4
beq 4f
mov r10,r4
add r4,r4,r9 @ yes -> add
str r4,[r1,r8,lsl #2]
cmp r4,#TOTAL
moveq r0,#2
beq 100f
mov r4,#0
str r4,[r1,r5,lsl #2]
add r6,r6,#1 @ empty case + 1
mov r0,#1
4:
add r7,r7,#1 @ no first digit
5: @ and loop
sub r2,r2,#1
cmp r2,#0
bge 2b
add r3,r3,#1
cmp r3,#SIZE
blt 1b
100:
pop {r1-r5,lr}
bx lr @ return
/******************************************************************/
/* move up */
/******************************************************************/
/* r0 return -1 if ok */
moveUp:
push {r1-r5,lr} @ save registers
ldr r1,iAdriTbCase
mov r0,#0
mov r3,#0
1:
mov r6,#0
mov r7,#0
mov r10,#0
mov r2,#0
2:
lsl r5,r2,#2 @ change this if size <> 4
add r5,r5,r3
ldr r4,[r1,r5,lsl #2]
cmp r4,#0
addeq r6,r6,#1 @ positions vides
beq 5f
cmp r6,#0
beq 3f @ no empty right case
mov r0,#0
str r0,[r1,r5,lsl #2] @ raz digit
lsl r0,r6,#2
sub r5,r5,r0
str r4,[r1,r5,lsl #2] @ and store to right empty position
mov r0,#1
3:
cmp r7,#0 @ first digit
beq 4f
sub r8,r5,#SIZE @ up digit
ldr r9,[r1,r8,lsl #2]
cmp r4,r9 @ equal ?
bne 4f
cmp r10,r4
beq 4f
mov r10,r4
add r4,r4,r9 @ yes -> add
str r4,[r1,r8,lsl #2]
cmp r4,#TOTAL
moveq r0,#2
beq 100f
mov r4,#0
str r4,[r1,r5,lsl #2]
add r6,r6,#1 @ empty case + 1
mov r0,#1
4:
add r7,r7,#1 @ no first digit
5: @ and loop
add r2,r2,#1
cmp r2,#SIZE
blt 2b
add r3,r3,#1
cmp r3,#SIZE
blt 1b
100:
pop {r1-r5,lr}
bx lr @ return
/******************************************************************/
/* add new digit on game */
/******************************************************************/
/* r0 return -1 if ok */
addDigit:
push {r1-r5,lr} @ save registers
sub sp,#4 * SIZE*SIZE
mov fp,sp
mov r0,#100
bl genereraleas
cmp r0,#10
movlt r5,#4
movge r5,#2
ldr r1,iAdriTbCase
mov r3,#0
mov r4,#0
1:
ldr r2,[r1,r3,lsl #2]
cmp r2,#0
bne 2f
str r3,[fp,r4,lsl #2]
add r4,r4,#1
2:
add r3,r3,#1
cmp r3,#SIZE*SIZE
blt 1b
cmp r4,#0 @ no empty case
moveq r0,#-1
beq 100f
cmp r4,#1
bne 3f
ldr r2,[fp] @ one case
str r5,[r1,r2,lsl #2]
mov r0,#0
b 100f
3: @ multiple case
sub r0,r4,#1
bl genereraleas
ldr r2,[fp,r0,lsl #2]
str r5,[r1,r2,lsl #2]
mov r0,#0
100:
add sp,#4* (SIZE*SIZE) @ stack alignement
pop {r1-r5,lr}
bx lr @ return
iAdriTbCase: .int iTbCase
/******************************************************************/
/* display game */
/******************************************************************/
displayGame:
push {r1-r3,lr} @ save registers
ldr r0,iAdrszClear1
bl affichageMess
ldr r0,iAdrszLineH
bl affichageMess
ldr r0,iAdrszLineVT
bl affichageMess
ldr r0,iAdrszLineV
bl affichageMess
ldr r1,iAdriTbCase
mov r2,#0
1:
ldr r0,[r1,r2,lsl #2]
bl digitString
bl affichageMess
ldr r0,iAdrszLineV
bl affichageMess
add r2,r2,#1
cmp r2,#SIZE
blt 1b
ldr r0,iAdrszCarriageReturn
bl affichageMess
ldr r0,iAdrszLineVT
bl affichageMess
ldr r0,iAdrszLineH
bl affichageMess
ldr r0,iAdrszLineVT
bl affichageMess
ldr r0,iAdrszLineV
bl affichageMess
2:
ldr r0,[r1,r2,lsl #2]
bl digitString
bl affichageMess
ldr r0,iAdrszLineV
bl affichageMess
add r2,r2,#1
cmp r2,#SIZE*2
blt 2b
ldr r0,iAdrszCarriageReturn
bl affichageMess
ldr r0,iAdrszLineVT
bl affichageMess
ldr r0,iAdrszLineH
bl affichageMess
ldr r0,iAdrszLineVT
bl affichageMess
ldr r0,iAdrszLineV
bl affichageMess
3:
ldr r0,[r1,r2,lsl #2]
bl digitString
bl affichageMess
ldr r0,iAdrszLineV
bl affichageMess
add r2,r2,#1
cmp r2,#SIZE*3
blt 3b
ldr r0,iAdrszCarriageReturn
bl affichageMess
ldr r0,iAdrszLineVT
bl affichageMess
ldr r0,iAdrszLineH
bl affichageMess
ldr r0,iAdrszLineVT
bl affichageMess
ldr r0,iAdrszLineV
bl affichageMess
4:
ldr r0,[r1,r2,lsl #2]
bl digitString
bl affichageMess
ldr r0,iAdrszLineV
bl affichageMess
add r2,r2,#1
cmp r2,#SIZE*4
blt 4b
ldr r0,iAdrszCarriageReturn
bl affichageMess
ldr r0,iAdrszLineVT
bl affichageMess
ldr r0,iAdrszLineH
bl affichageMess
100:
pop {r1-r3,lr}
bx lr @ return
iAdrszLineH: .int szLineH
iAdrszLineV: .int szLineV
iAdrszLineVT: .int szLineVT
//iAdrszMessMovePos: .int szMessMovePos
/******************************************************************/
/* digits string */
/******************************************************************/
/* r0 contains number */
/* r0 return address string */
digitString:
push {r1,lr} @ save registers
cmp r0,#0
bne 1f
ldr r0,iAdrszMess0
b 100f
1:
cmp r0,#2
bne 2f
ldr r0,iAdrszMess2
b 100f
2:
cmp r0,#4
bne 3f
ldr r0,iAdrszMess4
b 100f
3:
cmp r0,#8
bne 4f
ldr r0,iAdrszMess8
b 100f
4:
cmp r0,#16
bne 5f
ldr r0,iAdrszMess16
b 100f
5:
cmp r0,#32
bne 6f
ldr r0,iAdrszMess32
b 100f
6:
cmp r0,#64
bne 7f
ldr r0,iAdrszMess64
b 100f
7:
cmp r0,#128
bne 8f
ldr r0,iAdrszMess128
b 100f
8:
cmp r0,#256
bne 9f
ldr r0,iAdrszMess256
b 100f
9:
cmp r0,#512
bne 10f
ldr r0,iAdrszMess512
b 100f
10:
cmp r0,#1024
bne 11f
ldr r0,iAdrszMess1024
b 100f
11:
cmp r0,#2048
bne 12f
ldr r0,iAdrszMess2048
b 100f
12:
ldr r1,iAdrszMessErreur @ error message
bl displayError
100:
pop {r1,lr}
bx lr @ return
iAdrszMess0: .int szMess0
iAdrszMess2: .int szMess2
iAdrszMess4: .int szMess4
iAdrszMess8: .int szMess8
iAdrszMess16: .int szMess16
iAdrszMess32: .int szMess32
iAdrszMess64: .int szMess64
iAdrszMess128: .int szMess128
iAdrszMess256: .int szMess256
iAdrszMess512: .int szMess512
iAdrszMess1024: .int szMess1024
iAdrszMess2048: .int szMess2048
//iAdrsBuffer: .int sBuffer
/***************************************************/
/* Generation random number */
/***************************************************/
/* r0 contains limit */
genereraleas:
push {r1-r4,lr} @ save registers
ldr r4,iAdriGraine
ldr r2,[r4]
ldr r3,iNbDep1
mul r2,r3,r2
ldr r3,iNbDep2
add r2,r2,r3
str r2,[r4] @ maj de la graine pour l appel suivant
cmp r0,#0
beq 100f
add r1,r0,#1 @ divisor
mov r0,r2 @ dividende
bl division
mov r0,r3 @ résult = remainder
100: @ end function
pop {r1-r4,lr} @ restaur registers
bx lr @ return
/*****************************************************/
iAdriGraine: .int iGraine
iNbDep1: .int 0x343FD
iNbDep2: .int 0x269EC3
/***************************************************/
/* read touch */
/***************************************************/
readKey:
push {r1-r7,lr}
mov r5,#0
ldr r1,iAdriTouche @ buffer address
str r5,[r1] @ raz 4 bytes iTouche
/* read terminal state */
mov r0,#STDIN @ input console
mov r1,#TCGETS
ldr r2,iAdrstOldtio
mov r7, #IOCTL @ call system Linux
svc #0
cmp r0,#0 @ error ?
beq 1f
ldr r1,iAdrszMessErreur @ error message
bl displayError
mov r0,#-1
b 100f
1:
adr r0,sighandler @ adresse routine traitement signal
ldr r1,iAdrstSigAction @ adresse structure sigaction
str r0,[r1,#sa_handler] @ maj handler
mov r0,#SIGINT @ signal type
ldr r1,iAdrstSigAction
mov r2,#0 @ NULL
mov r7, #SIGACTION @ call system
svc #0
cmp r0,#0 @ error ?
bne 97f
mov r0,#SIGQUIT
ldr r1,iAdrstSigAction
mov r2,#0 @ NULL
mov r7, #SIGACTION @ call system
svc #0
cmp r0,#0 @ error ?
bne 97f
mov r0,#SIGTERM
ldr r1,iAdrstSigAction
mov r2,#0 @ NULL
mov r7, #SIGACTION @ appel systeme
svc #0
cmp r0,#0
bne 97f
@
adr r0,iSIG_IGN @ address signal ignore function
ldr r1,iAdrstSigAction1
str r0,[r1,#sa_handler]
mov r0,#SIGTTOU @invalidate other process signal
ldr r1,iAdrstSigAction1
mov r2,#0 @ NULL
mov r7,#SIGACTION @ call system
svc #0
cmp r0,#0
bne 97f
@
/* read terminal current state */
mov r0,#STDIN
mov r1,#TCGETS
ldr r2,iAdrstCurtio @ address current termio
mov r7,#IOCTL @ call systeme
svc #0
cmp r0,#0 @ error ?
bne 97f
mov r2,#ICANON | ECHO @ no key pressed echo on display
mvn r2,r2 @ and one key
ldr r1,iAdrstCurtio
ldr r3,[r1,#term_c_lflag]
and r3,r2 @ add flags
str r3,[r1,#term_c_lflag] @ and store
mov r0,#STDIN @ maj terminal current state
mov r1,#TCSETS
ldr r2,iAdrstCurtio
mov r7, #IOCTL @ call system
svc #0
cmp r0,#0
bne 97f
@
2: @ loop waiting key
ldr r0,iAdriEnd @ if signal ctrl-c -> end
ldr r0,[r0]
cmp r0,#0
movne r5,#-1
bne 98f
ldr r0,iAdrstPoll1 @ address structure poll
mov r1,#STDIN
str r1,[r0,#poll_fd] @ maj FD
mov r1,#POLLIN @ action code
str r1,[r0,#poll_events]
mov r1,#1 @ items number structure poll
mov r2,#0 @ timeout = 0
mov r7,#SYSPOLL @ call system POLL
svc #0
cmp r0,#0 @ key pressed ?
ble 2b @ no key pressed -> loop
@ read key
mov r0,#STDIN @ File Descriptor
ldr r1,iAdriTouche @ buffer address
mov r2,#BUFFERSIZE @ buffer size
mov r7,#READ @ read key
svc #0
cmp r0,#0 @ error ?
bgt 98f
97: @ error detected
ldr r1,iAdrszMessErreur @ error message
bl displayError
mov r5,#-1
98: @ end then restaur begin state terminal
mov r0,#STDIN
mov r1,#TCSETS
ldr r2,iAdrstOldtio
mov r7,#IOCTL @ call system
svc #0
cmp r0,#0
beq 99f @ restaur ok
ldr r1,iAdrszMessErreur @ error message
bl displayError
mov r0,#-1
b 100f
99:
cmp r5,#0 @ no error or control-c ?
ldreq r2,iAdriTouche @ key address
ldreqb r0,[r2,#2] @ return key byte
movne r0,r5 @ or error
100:
pop {r1-r7, lr}
bx lr
iSIG_IGN: .int 1
iAdriEnd: .int iEnd
iAdrstPoll1: .int stPoll1
iAdriTouche: .int iTouche
iAdrstOldtio: .int stOldtio
iAdrstCurtio: .int stCurtio
iAdrstSigAction: .int stSigAction
iAdrstSigAction1: .int stSigAction1
iAdrszMessErreur : .int szMessErreur
/******************************************************************/
/* traitement du signal */
/******************************************************************/
sighandler:
push {r0,r1}
ldr r0,iAdriEnd
mov r1,#1 @ maj zone end
str r1,[r0]
pop {r0,r1}
bx lr
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
|
http://rosettacode.org/wiki/4-rings_or_4-squares_puzzle | 4-rings or 4-squares puzzle | 4-rings or 4-squares puzzle
You are encouraged to solve this task according to the task description, using any language you may know.
Task
Replace a, b, c, d, e, f, and
g with the decimal
digits LOW ───► HIGH
such that the sum of the letters inside of each of the four large squares add up to
the same sum.
╔══════════════╗ ╔══════════════╗
║ ║ ║ ║
║ a ║ ║ e ║
║ ║ ║ ║
║ ┌───╫──────╫───┐ ┌───╫─────────┐
║ │ ║ ║ │ │ ║ │
║ │ b ║ ║ d │ │ f ║ │
║ │ ║ ║ │ │ ║ │
║ │ ║ ║ │ │ ║ │
╚══════════╪═══╝ ╚═══╪══════╪═══╝ │
│ c │ │ g │
│ │ │ │
│ │ │ │
└──────────────┘ └─────────────┘
Show all output here.
Show all solutions for each letter being unique with
LOW=1 HIGH=7
Show all solutions for each letter being unique with
LOW=3 HIGH=9
Show only the number of solutions when each letter can be non-unique
LOW=0 HIGH=9
Related task
Solve the no connection puzzle
| #Prolog | Prolog |
:- use_module(library(clpfd)).
% main predicate
my_sum(Min, Max, Top, LL):-
L = [A,B,C,D,E,F,G],
L ins Min..Max,
( Top == 0
-> all_distinct(L)
; true),
R #= A+B,
R #= B+C+D,
R #= D+E+F,
R #= F+G,
setof(L, labeling([ff], L), LL).
my_sum_1(Min, Max) :-
my_sum(Min, Max, 0, LL),
maplist(writeln, LL).
my_sum_2(Min, Max, Len) :-
my_sum(Min, Max, 1, LL),
length(LL, Len).
|
http://rosettacode.org/wiki/15_puzzle_solver | 15 puzzle solver | Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.
For this task you will be using the following puzzle:
15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
The output must show the moves' directions, like so: left, left, left, down, right... and so on.
There are two solutions, of fifty-two moves:
rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd
rrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd
see: Pretty Print of Optimal Solution
Finding either one, or both is an acceptable result.
Extra credit.
Solve the following problem:
0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1
Related Task
15 puzzle game
A* search algorithm
| #Common_Lisp | Common Lisp | ;;; Using a priority queue for the A* search
(eval-when (:load-toplevel :compile-toplevel :execute)
(ql:quickload "pileup"))
;; * The package definition
(defpackage :15-solver
(:use :common-lisp :pileup)
(:export "15-puzzle-solver" "*initial-state*" "*goal-state*"))
(in-package :15-solver)
;; * Data types
(defstruct (posn (:constructor posn))
"A posn is a pair struct containing two integer for the row/col indices."
(row 0 :type fixnum)
(col 0 :type fixnum))
(defstruct (state (:constructor state))
"A state contains a vector and a posn describing the position of the empty slot."
(matrix '#(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0) :type simple-vector)
(empty-slot (posn :row 3 :col 3) :type posn))
(defparameter directions '(up down left right)
"The possible directions shifting the empty slot.")
(defstruct (node (:constructor node))
"A node contains a state, a reference to the previous node, a g value (actual
costs until this node, and a f value (g value + heuristics)."
(state (state) :type state)
(prev nil)
(cost 0 :type fixnum)
(f-value 0 :type fixnum))
;; * Some constants
(defparameter *side-size* 4 "The size of the puzzle.")
(defvar *initial-state*
(state :matrix #(15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2)
:empty-slot (posn :row 2 :col 0)))
(defvar *initial-state-2*
(state :matrix #( 0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1)
:empty-slot (posn :row 0 :col 0)))
(defvar *goal-state*
(state :matrix #( 1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0)
:empty-slot (posn :row 3 :col 3)))
;; * The functions
;; ** Accessing the elements of the puzzle
(defun matrix-ref (matrix row col)
"Matrices are simple vectors, abstracted by following functions."
(svref matrix (+ (* row *side-size*) col)))
(defun (setf matrix-ref) (val matrix row col)
(setf (svref matrix (+ (* row *side-size*) col)) val))
;; ** The final predicate
(defun target-state-p (state goal-state)
"Returns T if STATE is the goal state."
(equalp state goal-state))
(defun valid-movement-p (direction empty-slot)
"Returns T if direction is allowed for the current empty slot position."
(case direction
(up (< (posn-row empty-slot) (1- *side-size*)))
(down (> (posn-row empty-slot) 0))
(left (< (posn-col empty-slot) (1- *side-size*)))
(right (> (posn-col empty-slot) 0))))
;; ** Pretty print the state
(defun print-state (state)
"Helper function to pretty-print a state."
(format t " ====================~%")
(loop
with matrix = (state-matrix state)
for i from 0 below *side-size*
do
(loop
for j from 0 below *side-size*
do (format t "| ~2,D " (matrix-ref matrix i j)))
(format t " |~%"))
(format t " ====================~%"))
;; ** Move the empty slot
(defun move (state direction)
"Returns a new state after moving STATE's empty-slot in DIRECTION assuming a
valid direction."
(let* ((matrix (copy-seq (state-matrix state)))
(empty-slot (state-empty-slot state))
(r (posn-row empty-slot))
(c (posn-col empty-slot))
(new-empty-slot
(ccase direction
(up (setf (matrix-ref matrix r c) (matrix-ref matrix (1+ r) c)
(matrix-ref matrix (1+ r) c) 0)
(posn :row (1+ r) :col c))
(down (setf (matrix-ref matrix r c) (matrix-ref matrix (1- r) c)
(matrix-ref matrix (1- r) c) 0)
(posn :row (1- r) :col c))
(left (setf (matrix-ref matrix r c) (matrix-ref matrix r (1+ c))
(matrix-ref matrix r (1+ c)) 0)
(posn :row r :col (1+ c)))
(right (setf (matrix-ref matrix r c) (matrix-ref matrix r (1- c))
(matrix-ref matrix r (1- c)) 0)
(posn :row r :col (1- c))))))
(state :matrix matrix :empty-slot new-empty-slot)))
;; ** The heuristics
(defun l1-distance (posn0 posn1)
"Returns the L1 distance between two positions."
(+ (abs (- (posn-row posn0) (posn-row posn1)))
(abs (- (posn-col posn0) (posn-col posn1)))))
(defun element-cost (val current-posn)
"Returns the L1 distance between the current position and the goal-position
for VAL."
(if (zerop val)
(l1-distance current-posn (posn :row 3 :col 3))
(multiple-value-bind (target-row target-col)
(floor (1- val) *side-size*)
(l1-distance current-posn (posn :row target-row :col target-col)))))
(defun distance-to-goal (state)
"Returns the L1 distance from STATE to the goal state."
(loop
with matrix = (state-matrix state)
with sum = 0
for i below *side-size*
do (loop
for j below *side-size*
for val = (matrix-ref matrix i j)
for cost = (element-cost val (posn :row i :col j))
unless (zerop val)
do (incf sum cost))
finally (return sum)))
(defun out-of-order-values (list)
"Returns the number of values out of order."
(flet ((count-values (list)
(loop
with a = (first list)
with rest = (rest list)
for b in rest
when (> b a)
count b)))
(loop
for candidates = list then (rest candidates)
while candidates
summing (count-values candidates) into result
finally (return (* 2 result)))))
(defun row-conflicts (row state0 state1)
"Returns the number of conflicts in the given row, i.e. value in the right row
but in the wrong order. For each conflicted pair add 2 to the value, but a
maximum of 6 to avoid over-estimation."
(let* ((goal-row (loop
with matrix1 = (state-matrix state1)
for j below *side-size*
collect (matrix-ref matrix1 row j)))
(in-goal-row (loop
with matrix0 = (state-matrix state0)
for j below *side-size*
for val = (matrix-ref matrix0 row j)
when (member val goal-row)
collect val)))
(min 6 (out-of-order-values
;; 0 does not lead to a linear conflict
(remove 0 (nreverse in-goal-row))))))
(defun col-conflicts (col state0 state1)
"Returns the number of conflicts in the given column, i.e. value in the right
row but in the wrong order. For each conflicted pair add 2 to the value, but a
maximum of 6 to avoid over-estimation."
(let* ((goal-col (loop
with matrix1 = (state-matrix state1)
for i below *side-size*
collect (matrix-ref matrix1 i col)))
(in-goal-col (loop
with matrix0 = (state-matrix state0)
for i below *side-size*
for val = (matrix-ref matrix0 i col)
when (member val goal-col)
collect val)))
(min 6 (out-of-order-values
;; 0 does not lead to a linear conflict
(remove 0 (nreverse in-goal-col))))))
(defun linear-conflicts (state0 state1)
"Returns the linear conflicts for state1 with respect to state0."
(loop
for i below *side-size*
for row-conflicts = (row-conflicts i state0 state1)
for col-conflicts = (col-conflicts i state0 state1)
summing row-conflicts into all-row-conflicts
summing col-conflicts into all-col-conflicts
finally (return (+ all-row-conflicts all-col-conflicts))))
(defun state-heuristics (state)
"Using the L1 distance and the number of linear conflicts as heuristics."
(+ (distance-to-goal state)
(linear-conflicts state *goal-state*)))
;; ** Generate the next possible states.
(defun next-state-dir-pairs (current-node)
"Returns a list of pairs containing the next states and the direction for the
movement of the empty slot."
(let* ((state (node-state current-node))
(empty-slot (state-empty-slot state))
(valid-movements (remove-if-not (lambda (dir) (valid-movement-p dir empty-slot))
directions)))
(map 'list (lambda (dir) (cons (move state dir) dir)) valid-movements)))
;; ** Searching the shortest paths and reconstructing the movements
(defun reconstruct-movements (leaf-node)
"Traverse all nodes until the initial state and return a list of symbols
describing the path."
(labels ((posn-diff (p0 p1)
;; Compute a pair describing the last move
(posn :row (- (posn-row p1) (posn-row p0))
:col (- (posn-col p1) (posn-col p0))))
(find-movement (prev-state state)
;; Describe the last movement of the empty slot with R, L, U or D.
(let* ((prev-empty-slot (state-empty-slot prev-state))
(this-empty-slot (state-empty-slot state))
(delta (posn-diff prev-empty-slot this-empty-slot)))
(cond ((equalp delta (posn :row 1 :col 0)) 'u)
((equalp delta (posn :row -1 :col 0)) 'd)
((equalp delta (posn :row 0 :col 1)) 'l)
((equalp delta (posn :row 0 :col -1)) 'r))))
(iter (node path)
(if (or (not node) (not (node-prev node)))
path
(iter (node-prev node)
(cons (find-movement (node-state node)
(node-state (node-prev node)))
path)))))
(iter leaf-node '())))
(defun A* (initial-state
&key (goal-state *goal-state*) (heuristics #'state-heuristics)
(information 0))
"An A* search for the shortest path to *GOAL-STATE*"
(let ((visited (make-hash-table :test #'equalp))) ; All states visited so far
;; Some internal helper functions
(flet ((pick-next-node (queue)
;; Get the next node from the queue
(heap-pop queue))
(expand-node (node queue)
;; Expand the next possible nodes from node and add them to the
;; queue if not already visited.
(loop
with costs = (node-cost node)
with successors = (next-state-dir-pairs node)
for (state . dir) in successors
for succ-cost = (1+ costs)
for f-value = (+ succ-cost (funcall heuristics state))
;; Check if this state was already looked at
unless (gethash state visited)
do
;; Insert the next node into the queue
(heap-insert
(node :state state :prev node :cost succ-cost
:f-value f-value)
queue))))
;; The actual A* search
(loop
;; The priority queue
with queue = (make-heap #'<= :name "queue" :size 1000 :key #'node-f-value)
with initial-state-cost = (funcall heuristics initial-state)
initially (heap-insert (node :state initial-state :prev nil :cost 0
:f-value initial-state-cost)
queue)
for counter from 1
for current-node = (pick-next-node queue)
for current-state = (node-state current-node)
;; Output some information each counter or nothing if information
;; equals 0.
when (and (not (zerop information))
(zerop (mod counter information)))
do (format t "~Dth State, heap size: ~D, current costs: ~D~%"
counter (heap-count queue)
(node-cost current-node))
;; If the target is not reached continue
until (target-state-p current-state goal-state)
do
;; Add the current state to the hash of visited states
(setf (gethash current-state visited) t)
;; Expand the current node and continue
(expand-node current-node queue)
finally (return (values (reconstruct-movements current-node) counter))))))
;; ** Pretty print the path
(defun print-path (path)
"Prints the directions of PATH and its length."
(format t "~{~A~} ~D moves~%" path (length path)))
;; ** Get some timing information
(defmacro timing (&body forms)
"Return both how much real time was spend in body and its result"
(let ((start (gensym))
(end (gensym))
(result (gensym)))
`(let* ((,start (get-internal-real-time))
(,result (progn ,@forms))
(,end (get-internal-real-time)))
(values ,result (/ (- ,end ,start) internal-time-units-per-second)))))
;; ** The main function
(defun 15-puzzle-solver (initial-state &key (goal-state *goal-state*))
"Solves a given and valid 15 puzzle and returns the shortest path to reach the
goal state."
(print-state initial-state)
(multiple-value-bind (result time)
(timing (multiple-value-bind (path steps)
(a* initial-state :goal-state goal-state)
(print-path path)
steps))
(format t "Found the shortest path in ~D steps and ~3,2F seconds~%" result time))
(print-state goal-state))
|
http://rosettacode.org/wiki/99_bottles_of_beer | 99 bottles of beer | Task
Display the complete lyrics for the song: 99 Bottles of Beer on the Wall.
The beer song
The lyrics follow this form:
99 bottles of beer on the wall
99 bottles of beer
Take one down, pass it around
98 bottles of beer on the wall
98 bottles of beer on the wall
98 bottles of beer
Take one down, pass it around
97 bottles of beer on the wall
... and so on, until reaching 0 (zero).
Grammatical support for 1 bottle of beer is optional.
As with any puzzle, try to do it in as creative/concise/comical a way
as possible (simple, obvious solutions allowed, too).
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
See also
http://99-bottles-of-beer.net/
Category:99_Bottles_of_Beer
Category:Programming language families
Wikipedia 99 bottles of beer
| #AmigaE | AmigaE | PROC main()
DEF t: PTR TO CHAR,
s: PTR TO CHAR,
u: PTR TO CHAR, i, x
t := 'Take one down, pass it around\n'
s := '\d bottle\s of beer\s\n'
u := ' on the wall'
FOR i := 99 TO 0 STEP -1
ForAll({x}, [u, NIL], `WriteF(s, i, IF i <> 1 THEN 's' ELSE NIL,
x))
IF i > 0 THEN WriteF(t)
ENDFOR
ENDPROC |
http://rosettacode.org/wiki/24_game | 24 game | The 24 Game tests one's mental arithmetic.
Task
Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
The goal is for the player to enter an expression that (numerically) evaluates to 24.
Only the following operators/functions are allowed: multiplication, division, addition, subtraction
Division should use floating point or rational arithmetic, etc, to preserve remainders.
Brackets are allowed, if using an infix expression evaluator.
Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
The order of the digits when given does not have to be preserved.
Notes
The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
The task is not for the program to generate the expression, or test whether an expression is even possible.
Related tasks
24 game/Solve
Reference
The 24 Game on h2g2.
| #D | D | import std.stdio, std.random, std.math, std.algorithm, std.range,
std.typetuple;
void main() {
void op(char c)() {
if (stack.length < 2)
throw new Exception("Wrong expression.");
stack[$ - 2] = mixin("stack[$ - 2]" ~ c ~ "stack[$ - 1]");
stack.popBack();
}
const problem = iota(4).map!(_ => uniform(1, 10))().array();
writeln("Make 24 with the digits: ", problem);
double[] stack;
int[] digits;
foreach (const char c; readln())
switch (c) {
case ' ', '\t', '\n': break;
case '1': .. case '9':
stack ~= c - '0';
digits ~= c - '0';
break;
foreach (o; TypeTuple!('+', '-', '*', '/')) {
case o: op!o(); break;
}
break;
default: throw new Exception("Wrong char: " ~ c);
}
if (!digits.sort().equal(problem.dup.sort()))
throw new Exception("Not using the given digits.");
if (stack.length != 1)
throw new Exception("Wrong expression.");
writeln("Result: ", stack[0]);
writeln(abs(stack[0] - 24) < 0.001 ? "Good job!" : "Try again.");
} |
http://rosettacode.org/wiki/9_billion_names_of_God_the_integer | 9 billion names of God the integer | This task is a variation of the short story by Arthur C. Clarke.
(Solvers should be aware of the consequences of completing this task.)
In detail, to specify what is meant by a “name”:
The integer 1 has 1 name “1”.
The integer 2 has 2 names “1+1”, and “2”.
The integer 3 has 3 names “1+1+1”, “2+1”, and “3”.
The integer 4 has 5 names “1+1+1+1”, “2+1+1”, “2+2”, “3+1”, “4”.
The integer 5 has 7 names “1+1+1+1+1”, “2+1+1+1”, “2+2+1”, “3+1+1”, “3+2”, “4+1”, “5”.
Task
Display the first 25 rows of a number triangle which begins:
1
1 1
1 1 1
1 2 1 1
1 2 2 1 1
1 3 3 2 1 1
Where row
n
{\displaystyle n}
corresponds to integer
n
{\displaystyle n}
, and each column
C
{\displaystyle C}
in row
m
{\displaystyle m}
from left to right corresponds to the number of names beginning with
C
{\displaystyle C}
.
A function
G
(
n
)
{\displaystyle G(n)}
should return the sum of the
n
{\displaystyle n}
-th row.
Demonstrate this function by displaying:
G
(
23
)
{\displaystyle G(23)}
,
G
(
123
)
{\displaystyle G(123)}
,
G
(
1234
)
{\displaystyle G(1234)}
, and
G
(
12345
)
{\displaystyle G(12345)}
.
Optionally note that the sum of the
n
{\displaystyle n}
-th row
P
(
n
)
{\displaystyle P(n)}
is the integer partition function.
Demonstrate this is equivalent to
G
(
n
)
{\displaystyle G(n)}
by displaying:
P
(
23
)
{\displaystyle P(23)}
,
P
(
123
)
{\displaystyle P(123)}
,
P
(
1234
)
{\displaystyle P(1234)}
, and
P
(
12345
)
{\displaystyle P(12345)}
.
Extra credit
If your environment is able, plot
P
(
n
)
{\displaystyle P(n)}
against
n
{\displaystyle n}
for
n
=
1
…
999
{\displaystyle n=1\ldots 999}
.
Related tasks
Partition function P
| #Wren | Wren | import "/big" for BigInt
import "/fmt" for Fmt
var cache = [[BigInt.one]]
var cumu = Fn.new { |n|
if (cache.count <= n) {
(cache.count..n).each { |l|
var r = [BigInt.zero]
(1..l).each { |x|
var min = l - x
if (x < min) min = x
r.add(r[-1] + cache[l - x][min])
}
cache.add(r)
}
}
return cache[n]
}
var row = Fn.new { |n|
var r = cumu.call(n)
return (0...n).map { |i| r[i+1] - r[i] }.toList
}
System.print("Rows:")
(1..25).each { |i|
Fmt.print("$2d: $s", i, row.call(i))
}
System.print("\nSums:")
[23, 123, 1234, 12345].each { |i|
Fmt.print("$5s: $s", i, cumu.call(i)[-1])
} |
http://rosettacode.org/wiki/A%2BB | A+B | A+B ─── a classic problem in programming contests, it's given so contestants can gain familiarity with the online judging system being used.
Task
Given two integers, A and B.
Their sum needs to be calculated.
Input data
Two integers are written in the input stream, separated by space(s):
(
−
1000
≤
A
,
B
≤
+
1000
)
{\displaystyle (-1000\leq A,B\leq +1000)}
Output data
The required output is one integer: the sum of A and B.
Example
input
output
2 2
4
3 2
5
| #C.2B.2B | C++ | // Standard input-output streams
#include <iostream>
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
cout << a + b << endl;
} |
http://rosettacode.org/wiki/Ackermann_function | Ackermann function | The Ackermann function is a classic example of a recursive function, notable especially because it is not a primitive recursive function. It grows very quickly in value, as does the size of its call tree.
The Ackermann function is usually defined as follows:
A
(
m
,
n
)
=
{
n
+
1
if
m
=
0
A
(
m
−
1
,
1
)
if
m
>
0
and
n
=
0
A
(
m
−
1
,
A
(
m
,
n
−
1
)
)
if
m
>
0
and
n
>
0.
{\displaystyle A(m,n)={\begin{cases}n+1&{\mbox{if }}m=0\\A(m-1,1)&{\mbox{if }}m>0{\mbox{ and }}n=0\\A(m-1,A(m,n-1))&{\mbox{if }}m>0{\mbox{ and }}n>0.\end{cases}}}
Its arguments are never negative and it always terminates.
Task
Write a function which returns the value of
A
(
m
,
n
)
{\displaystyle A(m,n)}
. Arbitrary precision is preferred (since the function grows so quickly), but not required.
See also
Conway chained arrow notation for the Ackermann function.
| #TSE_SAL | TSE SAL | // library: math: get: ackermann: recursive <description></description> <version>1.0.0.0.5</version> <version control></version control> (filenamemacro=getmaare.s) [kn, ri, tu, 27-12-2011 14:46:59]
INTEGER PROC FNMathGetAckermannRecursiveI( INTEGER mI, INTEGER nI )
IF ( mI == 0 )
RETURN( nI + 1 )
ENDIF
IF ( nI == 0 )
RETURN( FNMathGetAckermannRecursiveI( mI - 1, 1 ) )
ENDIF
RETURN( FNMathGetAckermannRecursiveI( mI - 1, FNMathGetAckermannRecursiveI( mI, nI - 1 ) ) )
END
PROC Main()
STRING s1[255] = "2"
STRING s2[255] = "3"
IF ( NOT ( Ask( "math: get: ackermann: recursive: m = ", s1, _EDIT_HISTORY_ ) ) AND ( Length( s1 ) > 0 ) ) RETURN() ENDIF
IF ( NOT ( Ask( "math: get: ackermann: recursive: n = ", s2, _EDIT_HISTORY_ ) ) AND ( Length( s2 ) > 0 ) ) RETURN() ENDIF
Message( FNMathGetAckermannRecursiveI( Val( s1 ), Val( s2 ) ) ) // gives e.g. 9
END |
http://rosettacode.org/wiki/ABC_problem | ABC problem | ABC problem
You are encouraged to solve this task according to the task description, using any language you may know.
You are given a collection of ABC blocks (maybe like the ones you had when you were a kid).
There are twenty blocks with two letters on each block.
A complete alphabet is guaranteed amongst all sides of the blocks.
The sample collection of blocks:
(B O)
(X K)
(D Q)
(C P)
(N A)
(G T)
(R E)
(T G)
(Q D)
(F S)
(J W)
(H U)
(V I)
(A N)
(O B)
(E R)
(F S)
(L Y)
(P C)
(Z M)
Task
Write a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.
The rules are simple:
Once a letter on a block is used that block cannot be used again
The function should be case-insensitive
Show the output on this page for the following 7 words in the following example
Example
>>> can_make_word("A")
True
>>> can_make_word("BARK")
True
>>> can_make_word("BOOK")
False
>>> can_make_word("TREAT")
True
>>> can_make_word("COMMON")
False
>>> can_make_word("SQUAD")
True
>>> can_make_word("CONFUSE")
True
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
| #Factor | Factor | USING: assocs combinators.short-circuit formatting grouping io
kernel math math.statistics qw sequences sets unicode ;
IN: rosetta-code.abc-problem
! === CONSTANTS ================================================
CONSTANT: blocks qw{
BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM
}
CONSTANT: input qw{ A BARK BOOK TREAT COMMON SQUAD CONFUSE }
! === PROGRAM LOGIC ============================================
: pare ( str -- seq )
[ blocks ] dip [ intersects? ] curry filter ;
: enough-blocks? ( str -- ? ) dup pare [ length ] bi@ <= ;
: enough-letters? ( str -- ? )
[ blocks concat ] dip dup [ within ] dip
[ histogram values ] bi@ [ - ] 2map [ neg? ] any? not ;
: can-make-word? ( str -- ? )
>upper { [ enough-blocks? ] [ enough-letters? ] } 1&& ;
! === OUTPUT ===================================================
: show-blocks ( -- )
"Available blocks:" print blocks [ 1 cut "(%s %s)" sprintf ]
map 5 group [ [ write bl ] each nl ] each nl ;
: header ( -- )
"Word" "Can make word from blocks?" "%-7s %s\n" printf
"======= ==========================" print ;
: result ( str -- )
dup can-make-word? "Yes" "No" ? "%-7s %s\n" printf ;
! === MAIN =====================================================
: abc-problem ( -- )
show-blocks header input [ result ] each ;
MAIN: abc-problem |
http://rosettacode.org/wiki/100_prisoners | 100 prisoners |
The Problem
100 prisoners are individually numbered 1 to 100
A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.
Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.
Prisoners start outside the room
They can decide some strategy before any enter the room.
Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.
A prisoner can open no more than 50 drawers.
A prisoner tries to find his own number.
A prisoner finding his own number is then held apart from the others.
If all 100 prisoners find their own numbers then they will all be pardoned. If any don't then all sentences stand.
The task
Simulate several thousand instances of the game where the prisoners randomly open drawers
Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:
First opening the drawer whose outside number is his prisoner number.
If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).
Show and compare the computed probabilities of success for the two strategies, here, on this page.
References
The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).
wp:100 prisoners problem
100 Prisoners Escape Puzzle DataGenetics.
Random permutation statistics#One hundred prisoners on Wikipedia.
| #Cowgol | Cowgol | include "cowgol.coh";
include "argv.coh";
# Parameters
const Drawers := 100; # Amount of drawers (and prisoners)
const Attempts := 50; # Amount of attempts a prisoner may make
const Simulations := 2000; # Amount of simulations to run
typedef NSim is int(0, Simulations);
# Random number generator
record RNG is
x: uint8;
a: uint8;
b: uint8;
c: uint8;
state @at(0): int32;
end record;
sub RandomByte(r: [RNG]): (byte: uint8) is
r.x := r.x + 1;
r.a := r.a ^ r.c ^ r.x;
r.b := r.b + r.a;
r.c := r.c + (r.b >> 1) ^ r.a;
byte := r.c;
end sub;
sub RandomUpTo(r: [RNG], limit: uint8): (rslt: uint8) is
var x: uint8 := 1;
while x < limit loop
x := x << 1;
end loop;
x := x - 1;
loop
rslt := RandomByte(r) & x;
if rslt < limit then
break;
end if;
end loop;
end sub;
# Drawers (though marked 0..99 instead of 1..100)
var drawers: uint8[Drawers];
typedef Drawer is @indexof drawers;
typedef Prisoner is Drawer;
# Place cards randomly in drawers
sub InitDrawers(r: [RNG]) is
var x: Drawer := 0;
while x < Drawers loop
drawers[x] := x;
x := x + 1;
end loop;
x := 0;
while x < Drawers - 1 loop
var y := x + RandomUpTo(r, Drawers-x);
var t := drawers[x];
drawers[x] := drawers[y];
drawers[y] := t;
x := x + 1;
end loop;
end sub;
# A prisoner can apply a strategy and either succeed or not
interface Strategy(p: Prisoner, r: [RNG]): (success: uint8);
# The stupid strategy: open drawers randomly.
sub Stupid implements Strategy is
# Let's assume the prisoner is smart enough not to reopen an open drawer
var opened: Drawer[Drawers];
MemZero(&opened[0], @bytesof opened);
# Open random drawers
success := 0;
var triesLeft: uint8 := Attempts;
while triesLeft != 0 loop
var d := RandomUpTo(r, Drawers); # grab a random drawer
if opened[d] != 0 then
continue; # Ignore it if a drawer was already open
else
triesLeft := triesLeft - 1;
opened[d] := 1;
if drawers[d] == p then # found it!
success := 1;
return;
end if;
end if;
end loop;
end sub;
# The optimal strategy: open the drawer for each number
sub Optimal implements Strategy is
var current := p;
var triesLeft: uint8 := Attempts;
success := 0;
while triesLeft != 0 loop
current := drawers[current];
if current == p then
success := 1;
return;
end if;
triesLeft := triesLeft - 1;
end loop;
end sub;
# Run a simulation
sub Simulate(s: Strategy, r: [RNG]): (success: uint8) is
InitDrawers(r); # place cards randomly in drawer
var p: Prisoner := 0;
success := 1; # if they all succeed the simulation succeeds
while p < Drawers loop # but for each prisoner...
if s(p, r) == 0 then # if he fails, the simulation fails
success := 0;
return;
end if;
p := p + 1;
end loop;
end sub;
# Run an amount of simulations and report the amount of successes
sub Run(n: NSim, s: Strategy, r: [RNG]): (successes: NSim) is
successes := 0;
while n > 0 loop
successes := successes + Simulate(s, r) as NSim;
n := n - 1;
end loop;
end sub;
# Initialize RNG with number given on command line (defaults to 0)
var rng: RNG; rng.state := 0;
ArgvInit();
var arg := ArgvNext();
if arg != 0 as [uint8] then
(rng.state, arg) := AToI(arg);
end if;
sub RunAndPrint(name: [uint8], strat: Strategy) is
print(name);
print(" strategy: ");
var succ := Run(Simulations, strat, &rng) as uint32;
print_i32(succ);
print(" out of ");
print_i32(Simulations);
print(" - ");
print_i32(succ * 100 / Simulations);
print("%\n");
end sub;
RunAndPrint("Stupid", Stupid);
RunAndPrint("Optimal", Optimal); |
http://rosettacode.org/wiki/Abundant_odd_numbers | Abundant odd numbers | An Abundant number is a number n for which the sum of divisors σ(n) > 2n,
or, equivalently, the sum of proper divisors (or aliquot sum) s(n) > n.
E.G.
12 is abundant, it has the proper divisors 1,2,3,4 & 6 which sum to 16 ( > 12 or n);
or alternately, has the sigma sum of 1,2,3,4,6 & 12 which sum to 28 ( > 24 or 2n).
Abundant numbers are common, though even abundant numbers seem to be much more common than odd abundant numbers.
To make things more interesting, this task is specifically about finding odd abundant numbers.
Task
Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.
Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.
Find and display here: the first abundant odd number greater than one billion (109) and either its proper divisor sum or sigma sum.
References
OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)
American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)
| #Swift | Swift | extension BinaryInteger {
@inlinable
public func factors(sorted: Bool = true) -> [Self] {
let maxN = Self(Double(self).squareRoot())
var res = Set<Self>()
for factor in stride(from: 1, through: maxN, by: 1) where self % factor == 0 {
res.insert(factor)
res.insert(self / factor)
}
return sorted ? res.sorted() : Array(res)
}
}
@inlinable
public func isAbundant<T: BinaryInteger>(n: T) -> (Bool, [T]) {
let divs = n.factors().dropLast()
return (divs.reduce(0, +) > n, Array(divs))
}
let oddAbundant = (0...).lazy.filter({ $0 & 1 == 1 }).map({ ($0, isAbundant(n: $0)) }).filter({ $1.0 })
for (n, (_, factors)) in oddAbundant.prefix(25) {
print("n: \(n); sigma: \(factors.reduce(0, +))")
}
let (bigA, (_, bigFactors)) =
(1_000_000_000...)
.lazy
.filter({ $0 & 1 == 1 })
.map({ ($0, isAbundant(n: $0)) })
.first(where: { $1.0 })!
print("first odd abundant number over 1 billion: \(bigA), sigma: \(bigFactors.reduce(0, +))") |
http://rosettacode.org/wiki/21_game | 21 game | 21 game
You are encouraged to solve this task according to the task description, using any language you may know.
21 is a two player game, the game is played by choosing
a number (1, 2, or 3) to be added to the running total.
The game is won by the player whose chosen number causes the running total
to reach exactly 21.
The running total starts at zero.
One player will be the computer.
Players alternate supplying a number to be added to the running total.
Task
Write a computer program that will:
do the prompting (or provide a button menu),
check for errors and display appropriate error messages,
do the additions (add a chosen number to the running total),
display the running total,
provide a mechanism for the player to quit/exit/halt/stop/close the program,
issue a notification when there is a winner, and
determine who goes first (maybe a random or user choice, or can be specified when the game begins).
| #Picat | Picat | import util.
main =>
N = 0,
Level = prompt("Level of play (1=dumb, 3=smart)"),
Algo = choosewisely,
if Level == "1" then
Algo := choosefoolishly
elseif Level == "2" then
Algo := choosesemiwisely
elseif Level != "3" then
println("Bad choice syntax--default to smart choice")
end,
Whofirst = prompt("Does computer go first? (y or n)"),
if Whofirst[1] == 'y' || Whofirst[1] == 'Y' then
N := apply(Algo, N)
end,
while (N < 21)
N := playermove(N),
if N == 21 then
println("Player wins! Game over, gg!"),
halt
end,
N := apply(Algo,N)
end.
trytowin(N) =>
if 21 - N < 4 then
printf("Computer chooses %w and wins. GG!\n", 21 - N),
halt
end.
choosewisely(N) = NextN =>
trytowin(N),
Targets = [1, 5, 9, 13, 17, 21],
once ((member(Target, Targets), Target > N)),
Bestmove = Target - N,
if Bestmove > 3 then
printf("Looks like I could lose. Choosing a 1, total now %w.\n", N + 1),
NextN = N+1
else
printf("On a roll, choosing a %w, total now %w.\n", Bestmove, N + Bestmove),
NextN = N + Bestmove
end.
choosefoolishly(N) = NextN =>
trytowin(N),
Move = random() mod 3 + 1,
printf("Here goes, choosing %w, total now %w.", Move, N+Move),
NextN = N+Move.
choosesemiwisely(N) = NextN =>
trytowin(N),
if frand() > 0.75 then
NextN = choosefoolishly(N)
else
NextN = choosewisely(N)
end.
prompt(S) = Input =>
printf(S ++ ": => "),
Input = strip(read_line()).
playermove(N) = NextN =>
Rang = cond(N > 19, "1 is all", cond(N > 18, "1 or 2", "1, 2 or 3")),
Prompt = to_fstring("Your choice (%s), 0 to exit", Rang),
Nstr = prompt(Prompt),
if Nstr == "0" then
halt
elseif Nstr == "1" then
NextN = N+1
elseif Nstr == "2" && N < 20 then
NextN = N + 2
elseif Nstr == "3" && N < 19 then
NextN = N + 3
else
NextN = playermove(N)
end.
|
http://rosettacode.org/wiki/24_game/Solve | 24 game/Solve | task
Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the 24 game.
Show examples of solutions generated by the program.
Related task
Arithmetic Evaluator
| #Fortran | Fortran | program solve_24
use helpers
implicit none
real :: vector(4), reals(4), p, q, r, s
integer :: numbers(4), n, i, j, k, a, b, c, d
character, parameter :: ops(4) = (/ '+', '-', '*', '/' /)
logical :: last
real,parameter :: eps = epsilon(1.0)
do n=1,12
call random_number(vector)
reals = 9 * vector + 1
numbers = int(reals)
call Insertion_Sort(numbers)
permutations: do
a = numbers(1); b = numbers(2); c = numbers(3); d = numbers(4)
reals = real(numbers)
p = reals(1); q = reals(2); r = reals(3); s = reals(4)
! combinations of operators:
do i=1,4
do j=1,4
do k=1,4
if ( abs(op(op(op(p,i,q),j,r),k,s)-24.0) < eps ) then
write (*,*) numbers, ' : ', '((',a,ops(i),b,')',ops(j),c,')',ops(k),d
exit permutations
else if ( abs(op(op(p,i,op(q,j,r)),k,s)-24.0) < eps ) then
write (*,*) numbers, ' : ', '(',a,ops(i),'(',b,ops(j),c,'))',ops(k),d
exit permutations
else if ( abs(op(p,i,op(op(q,j,r),k,s))-24.0) < eps ) then
write (*,*) numbers, ' : ', a,ops(i),'((',b,ops(j),c,')',ops(k),d,')'
exit permutations
else if ( abs(op(p,i,op(q,j,op(r,k,s)))-24.0) < eps ) then
write (*,*) numbers, ' : ', a,ops(i),'(',b,ops(j),'(',c,ops(k),d,'))'
exit permutations
else if ( abs(op(op(p,i,q),j,op(r,k,s))-24.0) < eps ) then
write (*,*) numbers, ' : ', '(',a,ops(i),b,')',ops(j),'(',c,ops(k),d,')'
exit permutations
end if
end do
end do
end do
call nextpermutation(numbers,last)
if ( last ) then
write (*,*) numbers, ' : no solution.'
exit permutations
end if
end do permutations
end do
contains
pure real function op(x,c,y)
integer, intent(in) :: c
real, intent(in) :: x,y
select case ( ops(c) )
case ('+')
op = x+y
case ('-')
op = x-y
case ('*')
op = x*y
case ('/')
op = x/y
end select
end function op
end program solve_24 |
http://rosettacode.org/wiki/15_puzzle_game | 15 puzzle game |
Task
Implement the Fifteen Puzzle Game.
The 15-puzzle is also known as:
Fifteen Puzzle
Gem Puzzle
Boss Puzzle
Game of Fifteen
Mystic Square
14-15 Puzzle
and some others.
Related Tasks
15 Puzzle Solver
16 Puzzle Game
| #68000_Assembly | 68000 Assembly | ;15 PUZZLE GAME
;Ram Variables
Cursor_X equ $00FF0000 ;Ram for Cursor Xpos
Cursor_Y equ $00FF0000+1 ;Ram for Cursor Ypos
joypad1 equ $00FF0002
GameRam equ $00FF1000 ;Ram for where the pieces are
GameRam_End equ $00FF100F ;the last valid slot in the array
;Video Ports
VDP_data EQU $C00000 ; VDP data, R/W word or longword access only
VDP_ctrl EQU $C00004 ; VDP control, word or longword writes only
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; VECTOR TABLE
;org $00000000
DC.L $00FFFFFE ;SP register value
DC.L ProgramStart ;Start of Program Code
DC.L IntReturn ; bus err
DC.L IntReturn ; addr err
DC.L IntReturn ; illegal inst
DC.L IntReturn ; divzero
DC.L IntReturn ; CHK
DC.L IntReturn ; TRAPV
DC.L IntReturn ; privilege viol
DC.L IntReturn ; TRACE
DC.L IntReturn ; Line A (1010) emulator
DC.L IntReturn ; Line F (1111) emulator
DC.L IntReturn,IntReturn,IntReturn,IntReturn ; Reserved /Coprocessor/Format err/ Uninit Interrupt
DC.L IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn
DC.L IntReturn ; spurious interrupt
DC.L IntReturn ; IRQ level 1
DC.L IntReturn ; IRQ level 2 EXT
DC.L IntReturn ; IRQ level 3
DC.L IntReturn ; IRQ level 4 Hsync
DC.L IntReturn ; IRQ level 5
DC.L IntReturn ; IRQ level 6 Vsync
DC.L IntReturn ; IRQ level 7 (NMI)
;org $00000080
;TRAPS
DC.L IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn
DC.L IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn
;org $000000C0
;FP/MMU
DC.L IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn
DC.L IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn,IntReturn
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Header
HEADER:
DC.B "SEGA GENESIS " ;System Name MUST TAKE UP 16 BYTES, USE PADDING IF NECESSARY
DC.B "(C)PDS " ;Copyright MUST TAKE UP 8 BYTES, USE PADDING IF NECESSARY
DC.B "2022.JUN" ;Date MUST TAKE UP 8 BYTES, USE PADDING IF NECESSARY
CARTNAME:
DC.B "15 PUZZLE"
CARTNAME_END:
DS.B 48-(CARTNAME_END-CARTNAME) ;ENSURES PROPER SPACING
CARTNAMEALT:
DC.B "15 PUZZLE"
CARTNAMEALT_END:
DS.B 48-(CARTNAMEALT_END-CARTNAMEALT) ;ENSURES PROPER SPACING
gameID:
DC.B "GM PUPPY001-00" ;TT NNNNNNNN-RR T=Type (GM=Game) N=game Num R=Revision
DC.W $0000 ;16-bit Checksum (Address $000200+)
CTRLDATA:
DC.B "J " ;Control Data (J=3button K=Keyboard 6=6button C=cdrom)
;(MUST TAKE UP 16 BYTES, USE PADDING IF NECESSARY)
ROMSTART:
DC.L $00000000 ;ROM Start
ROMLEN:
DC.L $003FFFFF ;ROM Length
RAMSTART:
DC.L $00FF0000
RAMEND:
DC.L $00FFFFFF ;RAM start/end (fixed)
DC.B " " ;External RAM Data (MUST TAKE UP 12 BYTES, USE PADDING IF NECESSARY)
DC.B " " ;Modem Data (MUST TAKE UP 12 BYTES, USE PADDING IF NECESSARY)
MEMO:
DC.B " " ;(MUST TAKE UP 40 BYTES, USE PADDING IF NECESSARY)
REGION:
DC.B "JUE " ;Regions Allowed (MUST TAKE UP 16 BYTES, USE PADDING IF NECESSARY)
even
HEADER_END:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Generic Interrupt Handler
IntReturn:
rte ;immediately return to game
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Program Start
ProgramStart:
;initialize TMSS (TradeMark Security System)
move.b ($A10001),D0 ;A10001 test the hardware version
and.b #$0F,D0
beq NoTmss ;branch if no TMSS chip
move.l #'SEGA',($A14000);A14000 disable TMSS
NoTmss:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Set Up Graphics
lea VDPSettings,A5 ;Initialize Screen Registers
move.l #VDPSettingsEnd-VDPSettings,D1 ;length of Settings
move.w (VDP_ctrl),D0 ;C00004 read VDP status (interrupt acknowledge?)
move.l #$00008000,d5 ;VDP Reg command (%8rvv)
NextInitByte:
move.b (A5)+,D5 ;get next video control byte
move.w D5,(VDP_ctrl) ;C00004 send write register command to VDP
; 8RVV - R=Reg V=Value
add.w #$0100,D5 ;point to next VDP register
dbra D1,NextInitByte ;loop for rest of block
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Set up palette
;Define palette
move.l #$C0000000,d0 ;Color 0 (background)
move.l d0,VDP_Ctrl
; ----BBB-GGG-RRR-
move.w #%0000011000000000,VDP_data
move.l #$C01E0000,d0 ;Color 15 (Font)
move.l d0,VDP_Ctrl
move.w #%0000000011101110,VDP_data
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Set up Font
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FONT IS 1BPP, THIS ROUTINE CONVERTS IT TO A 4BPP FORMAT.
lea Font,A1 ;Font Address in ROM
move.l #Font_End-Font,d6 ;Our font contains 96 letters 8 lines each
move.l #$40000000,(VDP_Ctrl);Start writes to VRAM address $0000
NextFont:
move.b (A1)+,d0 ;Get byte from font
moveq.l #7,d5 ;Bit Count (8 bits)
clr.l d1 ;Reset BuildUp Byte
Font_NextBit: ;1 color per nibble = 4 bytes
rol.l #3,d1 ;Shift BuildUp 3 bits left
roxl.b #1,d0 ;Shift a Bit from the 1bpp font into the Pattern
roxl.l #1,d1 ;Shift bit into BuildUp
dbra D5,Font_NextBit ;Next Bit from Font
move.l d1,d0 ; Make fontfrom Color 1 to color 15
rol.l #1,d1 ;Bit 1
or.l d0,d1
rol.l #1,d1 ;Bit 2
or.l d0,d1
rol.l #1,d1 ;Bit 3
or.l d0,d1
move.l d1,(VDP_Data);Write next Long of char (one line) to VDP
dbra d6,NextFont ;Loop until done
clr.b Cursor_X ;Clear Cursor XY
clr.b Cursor_Y
;Turn on screen
move.w #$8144,(VDP_Ctrl);C00004 reg 1 = 0x44 unblank display
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; all of the above was just the prep work to boot the Sega Genesis, and had nothing to do with a 15 Puzzle.
; That's hardware for you!
LEA GameRam,A0
;load the initial state of the puzzle. There is no randomization here unfortunately, as creating a sufficient pseudo-RNG
;to make the game "believable" is more difficult than programming the game itself!
;so instead we'll start in such a manner that the player has to do quite a bit of work to win.
MOVE.B #'F',(A0)+
MOVE.B #'E',(A0)+
MOVE.B #'D',(A0)+
MOVE.B #'C',(A0)+
MOVE.B #'B',(A0)+
MOVE.B #'A',(A0)+
MOVE.B #'9',(A0)+
MOVE.B #'8',(A0)+
MOVE.B #'7',(A0)+
MOVE.B #'6',(A0)+
MOVE.B #'5',(A0)+
MOVE.B #'4',(A0)+
MOVE.B #'3',(A0)+
MOVE.B #'2',(A0)+
MOVE.B #'1',(A0)+
MOVE.B #' ',(A0)+
;puzzle will look like:
;FEDC
;BA98
;7654
;321
main:
JSR Player_ReadControlsDual ;get controller input
move.w d0,(joypad1)
;adjust the number of these as you see fit.
;this affects the game's overall speed.
JSR waitVBlank
JSR waitVBlank
JSR waitVBlank
JSR waitVBlank
JSR waitVBlank
JSR waitVBlank
JSR waitVBlank
JSR waitVBlank
JSR waitVBlank
JSR waitVBlank
;find where the blank space is among GameRAM
LEA GameRAM,a0
MOVE.B #' ',D0
JSR REPNE_SCASB
MOVE.L A0,A1
;;;;;;;;;;;;;;;;;;; check controller presses
JOYPAD_BITFLAG_M equ 2048
JOYPAD_BITFLAG_Z equ 1024
JOYPAD_BITFLAG_Y equ 512
JOYPAD_BITFLAG_X equ 256
JOYPAD_BITFLAG_S equ 128
JOYPAD_BITFLAG_C equ 64
JOYPAD_BITFLAG_B equ 32
JOYPAD_BITFLAG_A equ 16
JOYPAD_BITFLAG_R equ 8
JOYPAD_BITFLAG_L equ 4
JOYPAD_BITFLAG_D equ 2
JOYPAD_BITFLAG_U equ 1
JOYPAD_BITNUM_M equ 11
JOYPAD_BITNUM_Z equ 10
JOYPAD_BITNUM_Y equ 9
JOYPAD_BITNUM_X equ 8
JOYPAD_BITNUM_S equ 7
JOYPAD_BITNUM_C equ 6
JOYPAD_BITNUM_B equ 5
JOYPAD_BITNUM_A equ 4
JOYPAD_BITNUM_R equ 3
JOYPAD_BITNUM_L equ 2
JOYPAD_BITNUM_D equ 1
JOYPAD_BITNUM_U equ 0
move.w (joypad1),D0
BTST #JOYPAD_BITNUM_U,D0
BNE JoyNotUp
MOVEM.L D0/A1,-(SP)
ADDA.L #4,A1
CMPA.L #GameRam_End,A1
BHI .doNothing
;OTHERWISE SWAP THE EMPTY SPACE WITH THE BYTE BELOW IT.
MOVE.B (A1),D7
MOVE.B (A0),(A1)
MOVE.B D7,(A0)
.doNothing
MOVEM.L (SP)+,D0/A1
bra vdraw
JoyNotUp:
BTST #JOYPAD_BITNUM_D,D0
BNE JoyNotDown
MOVEM.L D0/A1,-(SP)
SUBA.L #4,A1 ;CHECK ONE ROW ABOVE WHERE WE ARE
CMPA.L #GameRam,A1
BCS .doNothing ;if A1-4 IS BELOW THE START OF GAME RAM, DON'T MOVE
;OTHERWISE SWAP THE EMPTY SPACE WITH THE BYTE ABOVE IT.
MOVE.B (A1),D7
MOVE.B (A0),(A1)
MOVE.B D7,(A0)
.doNothing:
MOVEM.L (SP)+,D0/A1
bra vdraw
JoyNotDown:
BTST #JOYPAD_BITNUM_L,D0
BNE JoyNotLeft
MOVEM.L D0/A1,-(SP)
ADDA.L #1,A1
MOVE.L A1,D4
MOVE.L A0,D3
AND.L #3,D4
AND.L #3,D3
CMP.L D3,D4
BCS .doNothing
;OTHERWISE SWAP THE EMPTY SPACE WITH THE BYTE TO THE LEFT
MOVE.B (A1),D7
MOVE.B (A0),(A1)
MOVE.B D7,(A0)
.doNothing:
MOVEM.L (SP)+,D0/A1
bra vdraw
JoyNotLeft:
BTST #JOYPAD_BITNUM_R,D0
BNE JoyNotRight
MOVEM.L D0/A1,-(SP)
SUBA.L #1,A1
MOVE.L A1,D4
MOVE.L A0,D3
AND.L #3,D4
AND.L #3,D3
CMP.L D3,D4
BHI .doNothing
;OTHERWISE SWAP THE EMPTY SPACE WITH THE BYTE TO THE RIGHT
MOVE.B (A1),D7
MOVE.B (A0),(A1)
MOVE.B D7,(A0)
.doNothing:
MOVEM.L (SP)+,D0/A1
bra vdraw
JoyNotRight:
vdraw:
;this actually draws the current state of the puzzle to the screen.
LEA GameRam,A0
CLR.B (Cursor_X) ;reset text cursors to top left of screen
CLR.B (Cursor_Y)
;draw the puzzle
;anything insize a REPT N...ENDR block is in-lined N times, back to back.
rept 4
MOVE.B (A0)+,D0
JSR PrintChar
MOVE.B (A0)+,D0
JSR PrintChar
MOVE.B (A0)+,D0
JSR PrintChar
MOVE.B (A0)+,D0
JSR PrintChar ;we just finished drawing one row of the puzzle. Now, begin a new line and continue drawing.
jsr newline
endr
checkIfWin:
;YES THIS IS MESSY, I TRIED IT WITH A LOOP BUT IT WOULDN'T WORK SO I JUST UNROLLED THE LOOP.
LEA GameRam,a4
MOVE.B (A4)+,D5
CMP.B #'1',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'2',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'3',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'4',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'5',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'6',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'7',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'8',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'9',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'A',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'B',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'C',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'D',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'E',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #'F',D5
BNE .keepGoing
MOVE.B (A4)+,D5
CMP.B #' ',D5
BNE .keepGoing
clr.b (Cursor_X)
move.b #7,(Cursor_Y)
LEA victoryMessage,a3
jsr PrintString
jmp * ;game freezes after you win.
.keepGoing:
;it's unlikely that the label "main" is in range of here so I didn't bother checking and just assumed it was out of range.
;Otherwise I would have said "BEQ main" instead of BNE .keepGoing
jmp main
VictoryMessage:
DC.B "A WINNER IS YOU",255
EVEN
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
REPNE_SCASB:
;INPUT:
;A0 = POINTER TO START OF MEMORY
;D0 = THE BYTE TO SEARCH FOR
;OUTPUT = A0 POINTS TO THE BYTE THAT CONTAINED D0
MOVE.B (A0),D1
CMP.B D0,D1
BEQ .done
ADDA.L #1,A0
BRA REPNE_SCASB
.done:
RTS
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Player_ReadControlsDual:
move.b #%01000000,($A1000B) ; Set direction IOIIIIII (I=In O=Out)
move.l #$A10003,a0 ;RW port for player 1
move.b #$40,(a0) ; TH = 1
nop ;Delay
nop
move.b (a0),d2 ; d0.b = --CBRLDU Store in D2
move.b #$0,(a0) ; TH = 0
nop ;Delay
nop
move.b (a0),d1 ; d1.b = --SA--DU Store in D1
move.b #$40,(a0) ; TH = 1
nop ;Delay
nop
move.b #$0,(a0) ; TH = 0
nop ;Delay
nop
move.b #$40,(a0) ; TH = 1
nop ;Delay
nop
move.b (a0),d3 ; d1.b = --CBXYZM Store in D3
move.b #$0,(a0) ; TH = 0
clr.l d0 ;Clear buildup byte
roxr.b d2
roxr.b d0 ;U
roxr.b d2
roxr.b d0 ;D
roxr.b d2
roxr.b d0 ;L
roxr.b d2
roxr.b d0 ;R
roxr.b #5,d1
roxr.b d0 ;A
roxr.b d2
roxr.b d0 ;B
roxr.b d2
roxr.b d0 ;C
roxr.b d1
roxr.b d0 ;S
move.l d3,d1
roxl.l #7,d1 ;XYZ
and.l #%0000011100000000,d1
or.l d1,d0
move.l d3,d1
roxl.l #8,d1 ;M
roxl.l #3,d1
and.l #%0000100000000000,d1
or.l d1,d0
or.l #$FFFFF000,d0 ;Set unused bits to 1
;this returns player 1's buttons into D0 as the following:
;----MZYXSCBARLDU
rts
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
waitVBlank: ;Bit 3 defines if we're in Vblank
MOVE.L d0,-(sp)
.wait:
move.w VDP_ctrl,d0
and.w #%0000000000001000,d0 ;See if vblank is running
bne .wait ;wait until it is
waitVBlank2:
move.w VDP_ctrl,d0
and.w #%0000000000001000,d0 ;See if vblank is running
beq waitVBlank2 ;wait until it isnt
MOVE.L (SP)+,d0
rts
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintChar: ;Show D0 to screen
moveM.l d0-d7/a0-a7,-(sp)
and.l #$FF,d0 ;Keep only 1 byte
sub #32,d0 ;No Characters in our font below 32
PrintCharAlt:
Move.L #$40000003,d5 ;top 4=write, bottom $3=Cxxx range
clr.l d4 ;Tilemap at $C000+
Move.B (Cursor_Y),D4
rol.L #8,D4 ;move $-FFF to $-FFF----
rol.L #8,D4
rol.L #7,D4 ;2 bytes per tile * 64 tiles per line
add.L D4,D5 ;add $4------3
Move.B (Cursor_X),D4
rol.L #8,D4 ;move $-FFF to $-FFF----
rol.L #8,D4
rol.L #1,D4 ;2 bytes per tile
add.L D4,D5 ;add $4------3
MOVE.L D5,(VDP_ctrl) ; C00004 write next character to VDP
MOVE.W D0,(VDP_data) ; C00000 store next word of name data
addq.b #1,(Cursor_X) ;INC Xpos
move.b (Cursor_X),d0
cmp.b #39,d0
bls nextpixel_Xok
jsr NewLine ;If we're at end of line, start newline
nextpixel_Xok:
moveM.l (sp)+,d0-d7/a0-a7
rts
PrintString:
move.b (a3)+,d0 ;Read a character in from A3
cmp.b #255,d0
beq PrintString_Done ;return on 255
jsr PrintChar ;Print the Character
bra PrintString
PrintString_Done:
rts
NewLine:
addq.b #1,(Cursor_Y) ;INC Y
clr.b (Cursor_X) ;Zero X
rts
Font:
;1bpp font - 8x8 96 characters
;looks just like your typical "8-bit" font. You'll just have to take my word for it.
DC.B $00,$00,$00,$00,$00,$00,$00,$00,$18,$3c,$3c,$18,$18,$00,$18,$18
DC.B $36,$36,$12,$24,$00,$00,$00,$00,$00,$12,$7f,$24,$24,$fe,$48,$00
DC.B $00,$04,$1e,$28,$1c,$0a,$3c,$10,$00,$62,$64,$08,$10,$26,$46,$00
DC.B $00,$18,$24,$20,$12,$2c,$44,$3a,$18,$18,$08,$10,$00,$00,$00,$00
DC.B $08,$10,$20,$20,$20,$20,$10,$08,$10,$08,$04,$04,$04,$04,$08,$10
DC.B $00,$10,$38,$10,$28,$00,$00,$00,$00,$00,$10,$10,$7c,$10,$10,$00
DC.B $00,$00,$00,$00,$0c,$0c,$04,$08,$00,$00,$00,$00,$7e,$00,$00,$00
DC.B $00,$00,$00,$00,$00,$18,$18,$00,$01,$02,$04,$08,$10,$20,$40,$00
DC.B $1c,$26,$63,$63,$63,$32,$1c,$00,$0c,$1c,$0c,$0c,$0c,$0c,$3f,$00
DC.B $3e,$63,$07,$1e,$3c,$70,$7f,$00,$3f,$06,$0c,$1e,$03,$63,$3e,$00
DC.B $0e,$1e,$36,$66,$7f,$06,$06,$00,$7e,$60,$7e,$03,$03,$63,$3e,$00
DC.B $1e,$30,$60,$7e,$63,$63,$3e,$00,$7f,$63,$06,$0c,$18,$18,$18,$00
DC.B $3c,$62,$72,$3c,$4f,$43,$3e,$00,$3e,$63,$63,$3f,$03,$06,$3c,$00
DC.B $00,$18,$18,$00,$18,$18,$00,$00,$00,$0c,$0c,$00,$0c,$0c,$04,$08
DC.B $00,$00,$06,$18,$60,$18,$06,$00,$00,$00,$00,$7e,$00,$7e,$00,$00
DC.B $00,$00,$60,$18,$06,$18,$60,$00,$1c,$36,$36,$06,$0c,$00,$0c,$0c
DC.B $3c,$42,$99,$a1,$a1,$99,$42,$3c,$1c,$36,$63,$63,$7f,$63,$63,$00
DC.B $7e,$63,$63,$7e,$63,$63,$7e,$00,$1e,$33,$60,$60,$60,$33,$1e,$00
DC.B $7c,$66,$63,$63,$63,$66,$7c,$00,$3f,$30,$30,$3e,$30,$30,$3f,$00
DC.B $7f,$60,$60,$7e,$60,$60,$60,$00,$1f,$30,$60,$67,$63,$33,$1f,$00
DC.B $63,$63,$63,$7f,$63,$63,$63,$00,$3f,$0c,$0c,$0c,$0c,$0c,$3f,$00
DC.B $03,$03,$03,$03,$03,$63,$3e,$00,$63,$66,$6c,$78,$7c,$6e,$67,$00
DC.B $30,$30,$30,$30,$30,$30,$3f,$00,$63,$77,$7f,$7f,$6b,$63,$63,$00
DC.B $63,$73,$7b,$7f,$6f,$67,$63,$00,$3e,$63,$63,$63,$63,$63,$3e,$00
DC.B $7e,$63,$63,$63,$7e,$60,$60,$00,$3e,$63,$63,$63,$6f,$66,$3d,$00
DC.B $7e,$63,$63,$67,$7c,$6e,$67,$00,$3c,$66,$60,$3e,$03,$63,$3e,$00
DC.B $3f,$0c,$0c,$0c,$0c,$0c,$0c,$00,$63,$63,$63,$63,$63,$63,$3e,$00
DC.B $63,$63,$63,$77,$3e,$1c,$08,$00,$63,$63,$6b,$7f,$7f,$77,$63,$00
DC.B $63,$77,$3e,$1c,$3e,$77,$63,$00,$33,$33,$33,$1e,$0c,$0c,$0c,$00
DC.B $7f,$07,$0e,$1c,$38,$70,$7f,$00,$00,$38,$20,$20,$20,$20,$38,$00
DC.B $80,$40,$20,$10,$08,$04,$02,$00,$00,$1c,$04,$04,$04,$04,$1c,$00
DC.B $10,$28,$44,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$7e,$00
DC.B $00,$20,$10,$00,$00,$00,$00,$00,$00,$18,$04,$1c,$24,$2c,$1c,$00
DC.B $00,$20,$20,$38,$24,$24,$38,$00,$00,$00,$1c,$20,$20,$20,$1c,$00
DC.B $00,$04,$04,$1c,$24,$24,$1c,$00,$00,$00,$1c,$24,$3c,$20,$1c,$00
DC.B $00,$18,$24,$20,$30,$20,$20,$00,$00,$1c,$24,$24,$1c,$04,$3c,$00
DC.B $00,$20,$20,$38,$24,$24,$24,$00,$00,$10,$00,$10,$10,$10,$10,$00
DC.B $08,$00,$08,$08,$08,$08,$28,$10,$20,$20,$24,$28,$30,$28,$24,$00
DC.B $10,$10,$10,$10,$10,$10,$18,$00,$00,$00,$40,$68,$54,$54,$54,$00
DC.B $00,$00,$28,$34,$24,$24,$24,$00,$00,$00,$1c,$22,$22,$22,$1c,$00
DC.B $00,$00,$38,$24,$24,$38,$20,$20,$00,$00,$1c,$24,$24,$1c,$04,$04
DC.B $00,$00,$2c,$30,$20,$20,$20,$00,$00,$00,$1c,$20,$1c,$02,$3c,$00
DC.B $00,$10,$3c,$10,$10,$14,$08,$00,$00,$00,$24,$24,$24,$24,$1a,$00
DC.B $00,$00,$24,$24,$24,$14,$18,$00,$00,$00,$92,$92,$92,$5a,$6c,$00
DC.B $00,$00,$22,$14,$08,$14,$22,$00,$00,$00,$24,$24,$1c,$04,$18,$00
DC.B $00,$00,$3c,$04,$18,$20,$3c,$00,$00,$08,$10,$10,$20,$10,$10,$08
DC.B $18,$18,$18,$18,$18,$18,$18,$18,$00,$10,$08,$08,$04,$08,$08,$10
DC.B $00,$00,$00,$30,$4a,$04,$00,$00,$1c,$7f,$00,$7f,$55,$55,$55,$00
Font_End:
VDPSettings:
DC.B $04 ; 0 mode register 1 ---H-1M-
DC.B $04 ; 1 mode register 2 -DVdP---
DC.B $30 ; 2 name table base for scroll A (A=top 3 bits) --AAA--- = $C000
DC.B $3C ; 3 name table base for window (A=top 4 bits / 5 in H40 Mode) --AAAAA- = $F000
DC.B $07 ; 4 name table base for scroll B (A=top 3 bits) -----AAA = $E000
DC.B $6C ; 5 sprite attribute table base (A=top 7 bits / 6 in H40) -AAAAAAA = $D800
DC.B $00 ; 6 unused register --------
DC.B $00 ; 7 background color (P=Palette C=Color) --PPCCCC
DC.B $00 ; 8 unused register --------
DC.B $00 ; 9 unused register --------
DC.B $FF ;10 H interrupt register (L=Number of lines) LLLLLLLL
DC.B $00 ;11 mode register 3 ----IVHL
DC.B $81 ;12 mode register 4 (C bits both1 = H40 Cell) C---SIIC
DC.B $37 ;13 H scroll table base (A=Top 6 bits) --AAAAAA = $FC00
DC.B $00 ;14 unused register --------
DC.B $02 ;15 auto increment (After each Read/Write) NNNNNNNN
DC.B $01 ;16 scroll size (Horiz & Vert size of ScrollA & B) --VV--HH = 64x32 tiles
DC.B $00 ;17 window H position (D=Direction C=Cells) D--CCCCC
DC.B $00 ;18 window V position (D=Direction C=Cells) D--CCCCC
DC.B $FF ;19 DMA length count low LLLLLLLL
DC.B $FF ;20 DMA length count high HHHHHHHH
DC.B $00 ;21 DMA source address low LLLLLLLL
DC.B $00 ;22 DMA source address mid MMMMMMMM
DC.B $80 ;23 DMA source address high (C=CMD) CCHHHHHH
VDPSettingsEnd:
even |
http://rosettacode.org/wiki/2048 | 2048 | Task
Implement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.
Rules of the game
The rules are that on each turn the player must choose a direction (up, down, left or right).
All tiles move as far as possible in that direction, some move more than others.
Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.
A move is valid when at least one tile can be moved, if only by combination.
A new tile with the value of 2 is spawned at the end of each turn at a randomly chosen empty square (if there is one).
Adding a new tile on a blank space. Most of the time, a new 2 is to be added, and occasionally (10% of the time), a 4.
To win, the player must create a tile with the number 2048.
The player loses if no valid moves are possible.
The name comes from the popular open-source implementation of this game mechanic, 2048.
Requirements
"Non-greedy" movement.
The tiles that were created by combining other tiles should not be combined again during the same turn (move).
That is to say, that moving the tile row of:
[2][2][2][2]
to the right should result in:
......[4][4]
and not:
.........[8]
"Move direction priority".
If more than one variant of combining is possible, move direction shall indicate which combination will take effect.
For example, moving the tile row of:
...[2][2][2]
to the right should result in:
......[2][4]
and not:
......[4][2]
Check for valid moves. The player shouldn't be able to skip their turn by trying a move that doesn't change the board.
Check for a win condition.
Check for a lose condition.
| #AutoHotkey | AutoHotkey | Grid := [], s := 16, w := h := S * 4.5
Gui, font, s%s%
Gui, add, text, y1
loop, 4
{
row := A_Index
loop, 4
{
col := A_Index
if col = 1
Gui, add, button, v%row%_%col% xs y+1 w%w% h%h% -TabStop, % Grid[row,col] := 0
else
Gui, add, button, v%row%_%col% x+1 yp w%w% h%h% -TabStop, % Grid[row,col] := 0
}
}
Gui, show,, 2048
;------------------------------
Start:
for row, obj in Grid
for col, val in obj
Grid[row,col] := 0
Grid[1,1]:=2
ShowGrid()
return
;------------------------------
GuiClose:
ExitApp
return
;------------------------------
#IfWinActive, 2048
;------------------------------
up::
move := false
loop, 4
{
col := A_Index
Loop, 3
{
row := A_Index
if Grid[row, col] && (Grid[row, col] = Grid[row+1, col])
Grid[row, col] *=2 , Grid[row+1, col] := 0, move := true
}
}
loop, 4
{
row := A_Index
loop, 4
{
col := A_Index
loop, 4
if !Grid[row, col]
loop, 3
if !Grid[row, col] && Grid[row+A_Index, col]
{
Grid[row, col] := Grid[row+A_Index, col] , Grid[row+A_Index, col] := 0, move := true
if (Grid[row, col] = Grid[row-1, col])
Grid[row-1, col] *=2 , Grid[row, col] := 0, move := true
}
}
}
gosub, AddNew
return
;------------------------------
Down::
move := false
loop, 4
{
col := A_Index
Loop, 3
{
row := 5-A_Index
if Grid[row, col] && (Grid[row, col] = Grid[row-1, col])
Grid[row, col] *=2 , Grid[row-1, col] := 0, move := true
}
}
loop, 4
{
row := 5-A_Index
loop, 4
{
col := A_Index
loop, 4
if !Grid[row, col]
loop, 3
if !Grid[row, col] && Grid[row-A_Index, col]
{
Grid[row, col] := Grid[row-A_Index, col] , Grid[row-A_Index, col] := 0, move := true
if (Grid[row, col] = Grid[row+1, col])
Grid[row+1, col] *=2 , Grid[row, col] := 0, move := true
}
}
}
gosub, AddNew
return
;------------------------------
Left::
move := false
loop, 4
{
row := A_Index
Loop, 3
{
col := A_Index
if Grid[row, col] && (Grid[row, col] = Grid[row, col+1])
Grid[row, col] *=2 , Grid[row, col+1] := 0, move := true
}
}
loop, 4
{
col := A_Index
loop, 4
{
row := A_Index
loop, 4
if !Grid[row, col]
loop, 3
if !Grid[row, col] && Grid[row, col+A_Index]
{
Grid[row, col] := Grid[row, col+A_Index] , Grid[row, col+A_Index] := 0, move := true
if (Grid[row, col] = Grid[row, col-1])
Grid[row, col-1] *=2 , Grid[row, col] := 0, move := true
}
}
}
gosub, AddNew
return
;------------------------------
Right::
move := false
loop, 4
{
row := A_Index
Loop, 3
{
col := 5-A_Index
if Grid[row, col] && (Grid[row, col] = Grid[row, col-1])
Grid[row, col] *=2 , Grid[row, col-1] := 0, move := true
}
}
loop, 4
{
col := 5-A_Index
loop, 4
{
row := A_Index
loop, 4
if !Grid[row, col]
loop, 3
if !Grid[row, col] && Grid[row, col-A_Index]
{
Grid[row, col] := Grid[row, col-A_Index] , Grid[row, col-A_Index] := 0, move := true
if (Grid[row, col] = Grid[row, col+1])
Grid[row, col+1] *=2 , Grid[row, col] := 0, move := true
}
}
}
gosub, AddNew
return
;------------------------------
#IfWinActive
;------------------------------
AddNew:
if EndOfGame()
{
MsgBox Done `nPress OK to retry
goto start
}
return
;------------------------------
EndOfGame(){
global
if Move
AddRandom()
ShowGrid()
for row, obj in Grid
for col, val in obj
if !grid[row,col]
return 0
for row, obj in Grid
for col, val in obj
if (grid[row,col] = grid[row+1,col]) || (grid[row,col] = grid[row-1,col]) || (grid[row,col] = grid[row,col+1]) || (grid[row,col] = grid[row,col-1])
return 0
return 1
}
;------------------------------
ShowGrid(){
global Grid
for row, obj in Grid
for col, val in obj
{
GuiControl,, %row%_%col%, %val%
if val
GuiControl, Show, %row%_%col%
else
GuiControl, Hide, %row%_%col%
}
}
;------------------------------
AddRandom(){
global Grid
ShowGrid()
Sleep, 200
for row, obj in Grid
for col, val in obj
if !grid[row,col]
list .= (list?"`n":"") row "," col
Sort, list, random
Rnd := StrSplit(list, "`n").1
Grid[StrSplit(rnd, ",").1, StrSplit(rnd, ",").2] := 2
}
;------------------------------ |
http://rosettacode.org/wiki/4-rings_or_4-squares_puzzle | 4-rings or 4-squares puzzle | 4-rings or 4-squares puzzle
You are encouraged to solve this task according to the task description, using any language you may know.
Task
Replace a, b, c, d, e, f, and
g with the decimal
digits LOW ───► HIGH
such that the sum of the letters inside of each of the four large squares add up to
the same sum.
╔══════════════╗ ╔══════════════╗
║ ║ ║ ║
║ a ║ ║ e ║
║ ║ ║ ║
║ ┌───╫──────╫───┐ ┌───╫─────────┐
║ │ ║ ║ │ │ ║ │
║ │ b ║ ║ d │ │ f ║ │
║ │ ║ ║ │ │ ║ │
║ │ ║ ║ │ │ ║ │
╚══════════╪═══╝ ╚═══╪══════╪═══╝ │
│ c │ │ g │
│ │ │ │
│ │ │ │
└──────────────┘ └─────────────┘
Show all output here.
Show all solutions for each letter being unique with
LOW=1 HIGH=7
Show all solutions for each letter being unique with
LOW=3 HIGH=9
Show only the number of solutions when each letter can be non-unique
LOW=0 HIGH=9
Related task
Solve the no connection puzzle
| #Python | Python | import itertools
def all_equal(a,b,c,d,e,f,g):
return a+b == b+c+d == d+e+f == f+g
def foursquares(lo,hi,unique,show):
solutions = 0
if unique:
uorn = "unique"
citer = itertools.combinations(range(lo,hi+1),7)
else:
uorn = "non-unique"
citer = itertools.combinations_with_replacement(range(lo,hi+1),7)
for c in citer:
for p in set(itertools.permutations(c)):
if all_equal(*p):
solutions += 1
if show:
print str(p)[1:-1]
print str(solutions)+" "+uorn+" solutions in "+str(lo)+" to "+str(hi)
print |
http://rosettacode.org/wiki/15_puzzle_solver | 15 puzzle solver | Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.
For this task you will be using the following puzzle:
15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
The output must show the moves' directions, like so: left, left, left, down, right... and so on.
There are two solutions, of fifty-two moves:
rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd
rrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd
see: Pretty Print of Optimal Solution
Finding either one, or both is an acceptable result.
Extra credit.
Solve the following problem:
0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1
Related Task
15 puzzle game
A* search algorithm
| #F.23 | F# |
// A Naive 15 puzzle solver using no memory. Nigel Galloway: October 6th., 2017
let Nr,Nc = [|3;0;0;0;0;1;1;1;1;2;2;2;2;3;3;3|],[|3;0;1;2;3;0;1;2;3;0;1;2;3;0;1;2|]
type G= |N |I |G |E |L
type N={i:uint64;g:G list;e:int;l:int}
let fN n=let g=(11-n.e)*4 in let a=n.i&&&(15UL<<<g)
{i=n.i-a+(a<<<16);g=N::n.g;e=n.e+4;l=n.l+(if Nr.[int(a>>>g)]<=n.e/4 then 0 else 1)}
let fI i=let g=(19-i.e)*4 in let a=i.i&&&(15UL<<<g)
{i=i.i-a+(a>>>16);g=I::i.g;e=i.e-4;l=i.l+(if Nr.[int(a>>>g)]>=i.e/4 then 0 else 1)}
let fG g=let l=(14-g.e)*4 in let a=g.i&&&(15UL<<<l)
{i=g.i-a+(a<<<4) ;g=G::g.g;e=g.e+1;l=g.l+(if Nc.[int(a>>>l)]<=g.e%4 then 0 else 1)}
let fE e=let l=(16-e.e)*4 in let a=e.i&&&(15UL<<<l)
{i=e.i-a+(a>>>4) ;g=E::e.g;e=e.e-1;l=e.l+(if Nc.[int(a>>>l)]>=e.e%4 then 0 else 1)}
let fL=let l=[|[I;E];[I;G;E];[I;G;E];[I;G];[N;I;E];[N;I;G;E];[N;I;G;E];[N;I;G];[N;I;E];[N;I;G;E];[N;I;G;E];[N;I;G];[N;E];[N;G;E];[N;G;E];[N;G];|]
(fun n g->List.except [g] l.[n] |> List.map(fun n->match n with N->fI |I->fN |G->fE |E->fG))
let solve n g l=let rec solve n=match n with // n is board, g is pos of 0, l is max depth
|n when n.i =0x123456789abcdef0UL->Some(n.g)
|n when n.l>l ->None
|g->let rec fN=function h::t->match solve h with None->fN t |n->n
|_->None
fN (fL g.e (List.head n.g)|>List.map(fun n->n g))
solve {i=n;g=[L];e=g;l=0}
let n = Seq.collect fN n
|
http://rosettacode.org/wiki/99_bottles_of_beer | 99 bottles of beer | Task
Display the complete lyrics for the song: 99 Bottles of Beer on the Wall.
The beer song
The lyrics follow this form:
99 bottles of beer on the wall
99 bottles of beer
Take one down, pass it around
98 bottles of beer on the wall
98 bottles of beer on the wall
98 bottles of beer
Take one down, pass it around
97 bottles of beer on the wall
... and so on, until reaching 0 (zero).
Grammatical support for 1 bottle of beer is optional.
As with any puzzle, try to do it in as creative/concise/comical a way
as possible (simple, obvious solutions allowed, too).
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
See also
http://99-bottles-of-beer.net/
Category:99_Bottles_of_Beer
Category:Programming language families
Wikipedia 99 bottles of beer
| #Apache_Ant | Apache Ant | <?xml version="1.0"?>
<project name="n bottles" default="99_bottles">
<!-- ant-contrib.sourceforge.net for arithmetic and if -->
<taskdef resource="net/sf/antcontrib/antcontrib.properties"/>
<!-- start count of bottles, you can set this with
e.g. ant -f 99.xml -Dcount=10 -->
<property name="count" value="99"/>
<target name="99_bottles">
<antcall target="bottle">
<param name="number" value="${count}"/>
</antcall>
</target>
<target name="bottle">
<echo message="${number} bottles of beer on the wall"/>
<echo message="${number} bottles of beer"/>
<echo message="Take one down, pass it around"/>
<math result="result" operand1="${number}" operation="-" operand2="1" datatype="int"/>
<echo message="${result} bottles of beer on the wall"/>
<if>
<not><equals arg1="${result}" arg2="0" /></not>
<then>
<antcall target="bottleiterate">
<param name="number" value="${result}"/>
</antcall>
</then>
</if>
</target>
<target name="bottleiterate">
<antcall target="bottle">
<param name="number" value="${number}"/>
</antcall>
</target>
</project> |
http://rosettacode.org/wiki/24_game | 24 game | The 24 Game tests one's mental arithmetic.
Task
Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
The goal is for the player to enter an expression that (numerically) evaluates to 24.
Only the following operators/functions are allowed: multiplication, division, addition, subtraction
Division should use floating point or rational arithmetic, etc, to preserve remainders.
Brackets are allowed, if using an infix expression evaluator.
Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
The order of the digits when given does not have to be preserved.
Notes
The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
The task is not for the program to generate the expression, or test whether an expression is even possible.
Related tasks
24 game/Solve
Reference
The 24 Game on h2g2.
| #EchoLisp | EchoLisp |
(string-delimiter "")
;; check that nums are in expr, and only once
(define (is-valid? expr sorted: nums)
(when (equal? 'q expr) (error "24-game" "Thx for playing"))
(unless (and
(list? expr)
(equal? nums (list-sort < (filter number? (flatten expr)))))
(writeln "🎃 Please use" nums)
#f))
;; 4 random digits
(define (gen24)
(->> (append (range 1 10)(range 1 10)) shuffle (take 4) (list-sort < )))
(define (is-24? num)
(unless (= 24 num)
(writeln "😧 Sorry - Result = " num)
#f))
(define (check-24 expr)
(if (and
(is-valid? expr nums)
(is-24? (js-eval (string expr)))) ;; use js evaluator
"🍀 🌸 Congrats - (play24) for another one."
(input-expr check-24 (string nums))))
(define nums null)
(define (play24)
(set! nums (gen24))
(writeln "24-game - Can you combine" nums "to get 24 ❓ (q to exit)")
(input-expr check-24 (string-append (string nums) " -> 24 ❓")))
|
http://rosettacode.org/wiki/9_billion_names_of_God_the_integer | 9 billion names of God the integer | This task is a variation of the short story by Arthur C. Clarke.
(Solvers should be aware of the consequences of completing this task.)
In detail, to specify what is meant by a “name”:
The integer 1 has 1 name “1”.
The integer 2 has 2 names “1+1”, and “2”.
The integer 3 has 3 names “1+1+1”, “2+1”, and “3”.
The integer 4 has 5 names “1+1+1+1”, “2+1+1”, “2+2”, “3+1”, “4”.
The integer 5 has 7 names “1+1+1+1+1”, “2+1+1+1”, “2+2+1”, “3+1+1”, “3+2”, “4+1”, “5”.
Task
Display the first 25 rows of a number triangle which begins:
1
1 1
1 1 1
1 2 1 1
1 2 2 1 1
1 3 3 2 1 1
Where row
n
{\displaystyle n}
corresponds to integer
n
{\displaystyle n}
, and each column
C
{\displaystyle C}
in row
m
{\displaystyle m}
from left to right corresponds to the number of names beginning with
C
{\displaystyle C}
.
A function
G
(
n
)
{\displaystyle G(n)}
should return the sum of the
n
{\displaystyle n}
-th row.
Demonstrate this function by displaying:
G
(
23
)
{\displaystyle G(23)}
,
G
(
123
)
{\displaystyle G(123)}
,
G
(
1234
)
{\displaystyle G(1234)}
, and
G
(
12345
)
{\displaystyle G(12345)}
.
Optionally note that the sum of the
n
{\displaystyle n}
-th row
P
(
n
)
{\displaystyle P(n)}
is the integer partition function.
Demonstrate this is equivalent to
G
(
n
)
{\displaystyle G(n)}
by displaying:
P
(
23
)
{\displaystyle P(23)}
,
P
(
123
)
{\displaystyle P(123)}
,
P
(
1234
)
{\displaystyle P(1234)}
, and
P
(
12345
)
{\displaystyle P(12345)}
.
Extra credit
If your environment is able, plot
P
(
n
)
{\displaystyle P(n)}
against
n
{\displaystyle n}
for
n
=
1
…
999
{\displaystyle n=1\ldots 999}
.
Related tasks
Partition function P
| #Yabasic | Yabasic | clear screen
Sub nine_billion_names(rows)
local p(rows, rows), i, j, column
p(1, 1) = 1
For i = 2 To rows
For j = 1 To i
p(i, j) = p(i - 1, j - 1) + p(i - j, j)
Next j
Next i
For i = 1 To rows
column = rows * 2 - 2 * i - 2
For j = 1 To i
Print at(column + j * 4 + (1 - len(str$(p(i, j)))), i), p(i, j)
Next j
Next i
End Sub
nine_billion_names(20) |
http://rosettacode.org/wiki/9_billion_names_of_God_the_integer | 9 billion names of God the integer | This task is a variation of the short story by Arthur C. Clarke.
(Solvers should be aware of the consequences of completing this task.)
In detail, to specify what is meant by a “name”:
The integer 1 has 1 name “1”.
The integer 2 has 2 names “1+1”, and “2”.
The integer 3 has 3 names “1+1+1”, “2+1”, and “3”.
The integer 4 has 5 names “1+1+1+1”, “2+1+1”, “2+2”, “3+1”, “4”.
The integer 5 has 7 names “1+1+1+1+1”, “2+1+1+1”, “2+2+1”, “3+1+1”, “3+2”, “4+1”, “5”.
Task
Display the first 25 rows of a number triangle which begins:
1
1 1
1 1 1
1 2 1 1
1 2 2 1 1
1 3 3 2 1 1
Where row
n
{\displaystyle n}
corresponds to integer
n
{\displaystyle n}
, and each column
C
{\displaystyle C}
in row
m
{\displaystyle m}
from left to right corresponds to the number of names beginning with
C
{\displaystyle C}
.
A function
G
(
n
)
{\displaystyle G(n)}
should return the sum of the
n
{\displaystyle n}
-th row.
Demonstrate this function by displaying:
G
(
23
)
{\displaystyle G(23)}
,
G
(
123
)
{\displaystyle G(123)}
,
G
(
1234
)
{\displaystyle G(1234)}
, and
G
(
12345
)
{\displaystyle G(12345)}
.
Optionally note that the sum of the
n
{\displaystyle n}
-th row
P
(
n
)
{\displaystyle P(n)}
is the integer partition function.
Demonstrate this is equivalent to
G
(
n
)
{\displaystyle G(n)}
by displaying:
P
(
23
)
{\displaystyle P(23)}
,
P
(
123
)
{\displaystyle P(123)}
,
P
(
1234
)
{\displaystyle P(1234)}
, and
P
(
12345
)
{\displaystyle P(12345)}
.
Extra credit
If your environment is able, plot
P
(
n
)
{\displaystyle P(n)}
against
n
{\displaystyle n}
for
n
=
1
…
999
{\displaystyle n=1\ldots 999}
.
Related tasks
Partition function P
| #zkl | zkl | var [const] BN=Import.lib("zklBigNum");
const N=0d100_000;
p:=List.createLong(N+1,BN.fp(0),True); // (0,0,...) all different
fcn calc(n,p){
p[n].set(0); // reset array for each run
foreach k in ([1..n]){
d:=n - k *(3*k - 1)/2;
do(2){
if (d<0) break(2);
if (k.isOdd) p[n].add(p[d]);
else p[n].sub(p[d]);
d-=k;
}
}
} |
http://rosettacode.org/wiki/A%2BB | A+B | A+B ─── a classic problem in programming contests, it's given so contestants can gain familiarity with the online judging system being used.
Task
Given two integers, A and B.
Their sum needs to be calculated.
Input data
Two integers are written in the input stream, separated by space(s):
(
−
1000
≤
A
,
B
≤
+
1000
)
{\displaystyle (-1000\leq A,B\leq +1000)}
Output data
The required output is one integer: the sum of A and B.
Example
input
output
2 2
4
3 2
5
| #Ceylon | Ceylon | shared void run() {
print("please enter two numbers for me to add");
value input = process.readLine();
if (exists input) {
value tokens = input.split().map(Integer.parse);
if (tokens.any((element) => element is ParseException)) {
print("numbers only, please");
return;
}
value numbers = tokens.narrow<Integer>();
if (numbers.size != 2) {
print("two numbers, please");
}
else if (!numbers.every((Integer element) => -1k <= element <= 1k)) {
print("only numbers between -1000 and 1000, please");
}
else if (exists a = numbers.first, exists b = numbers.last) {
print(a + b);
}
else {
print("something went wrong");
}
}
} |
http://rosettacode.org/wiki/Ackermann_function | Ackermann function | The Ackermann function is a classic example of a recursive function, notable especially because it is not a primitive recursive function. It grows very quickly in value, as does the size of its call tree.
The Ackermann function is usually defined as follows:
A
(
m
,
n
)
=
{
n
+
1
if
m
=
0
A
(
m
−
1
,
1
)
if
m
>
0
and
n
=
0
A
(
m
−
1
,
A
(
m
,
n
−
1
)
)
if
m
>
0
and
n
>
0.
{\displaystyle A(m,n)={\begin{cases}n+1&{\mbox{if }}m=0\\A(m-1,1)&{\mbox{if }}m>0{\mbox{ and }}n=0\\A(m-1,A(m,n-1))&{\mbox{if }}m>0{\mbox{ and }}n>0.\end{cases}}}
Its arguments are never negative and it always terminates.
Task
Write a function which returns the value of
A
(
m
,
n
)
{\displaystyle A(m,n)}
. Arbitrary precision is preferred (since the function grows so quickly), but not required.
See also
Conway chained arrow notation for the Ackermann function.
| #TXR | TXR | (defmacro defmemofun (name (. args) . body)
(let ((hash (gensym "hash-"))
(argl (gensym "args-"))
(hent (gensym "hent-"))
(uniq (copy-str "uniq")))
^(let ((,hash (hash :equal-based)))
(defun ,name (,*args)
(let* ((,argl (list ,*args))
(,hent (inhash ,hash ,argl ,uniq)))
(if (eq (cdr ,hent) ,uniq)
(set (cdr ,hent) (block ,name (progn ,*body)))
(cdr ,hent)))))))
(defmemofun ack (m n)
(cond
((= m 0) (+ n 1))
((= n 0) (ack (- m 1) 1))
(t (ack (- m 1) (ack m (- n 1))))))
(each ((i (range 0 3)))
(each ((j (range 0 4)))
(format t "ack(~a, ~a) = ~a\n" i j (ack i j)))) |
http://rosettacode.org/wiki/ABC_problem | ABC problem | ABC problem
You are encouraged to solve this task according to the task description, using any language you may know.
You are given a collection of ABC blocks (maybe like the ones you had when you were a kid).
There are twenty blocks with two letters on each block.
A complete alphabet is guaranteed amongst all sides of the blocks.
The sample collection of blocks:
(B O)
(X K)
(D Q)
(C P)
(N A)
(G T)
(R E)
(T G)
(Q D)
(F S)
(J W)
(H U)
(V I)
(A N)
(O B)
(E R)
(F S)
(L Y)
(P C)
(Z M)
Task
Write a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.
The rules are simple:
Once a letter on a block is used that block cannot be used again
The function should be case-insensitive
Show the output on this page for the following 7 words in the following example
Example
>>> can_make_word("A")
True
>>> can_make_word("BARK")
True
>>> can_make_word("BOOK")
False
>>> can_make_word("TREAT")
True
>>> can_make_word("COMMON")
False
>>> can_make_word("SQUAD")
True
>>> can_make_word("CONFUSE")
True
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
| #FBSL | FBSL |
#APPTYPE CONSOLE
SUB MAIN()
BlockCheck("A")
BlockCheck("BARK")
BlockCheck("BooK")
BlockCheck("TrEaT")
BlockCheck("comMON")
BlockCheck("sQuAd")
BlockCheck("Confuse")
pause
END SUB
FUNCTION BlockCheck(str)
PRINT str " " iif( Blockable( str ), "can", "cannot" ) " be spelled with blocks."
END FUNCTION
FUNCTION Blockable(str AS STRING)
DIM blocks AS STRING = "BOXKDQCPNAGTRETGQDFSJWHUVIANOBERFSLYPCZM"
DIM C AS STRING = ""
DIM POS AS INTEGER = 0
FOR DIM I = 1 TO LEN(str)
C = str{i}
POS = INSTR(BLOCKS, C, 0, 1) 'case insensitive
IF POS > 0 THEN
'if the pos is odd, it's the first of the pair
IF POS MOD 2 = 1 THEN
'so clear the first and the second
POKE(@blocks + POS - 1," ")
POKE(@blocks + POS," ")
'otherwise, it's the last of the pair
ELSE
'clear the second and the first
POKE(@blocks + POS - 1," ")
POKE(@blocks + POS - 2," ")
END IF
ELSE
'not found, so can't be spelled
RETURN FALSE
END IF
NEXT
'got thru to here, so can be spelled
RETURN TRUE
END FUNCTION
|
http://rosettacode.org/wiki/100_prisoners | 100 prisoners |
The Problem
100 prisoners are individually numbered 1 to 100
A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.
Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.
Prisoners start outside the room
They can decide some strategy before any enter the room.
Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.
A prisoner can open no more than 50 drawers.
A prisoner tries to find his own number.
A prisoner finding his own number is then held apart from the others.
If all 100 prisoners find their own numbers then they will all be pardoned. If any don't then all sentences stand.
The task
Simulate several thousand instances of the game where the prisoners randomly open drawers
Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:
First opening the drawer whose outside number is his prisoner number.
If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).
Show and compare the computed probabilities of success for the two strategies, here, on this page.
References
The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).
wp:100 prisoners problem
100 Prisoners Escape Puzzle DataGenetics.
Random permutation statistics#One hundred prisoners on Wikipedia.
| #Crystal | Crystal | prisoners = (1..100).to_a
N = 100_000
generate_rooms = ->{ (1..100).to_a.shuffle }
res = N.times.count do
rooms = generate_rooms.call
prisoners.all? { |pr| rooms[1, 100].sample(50).includes?(pr) }
end
puts "Random strategy : %11.4f %%" % (res.fdiv(N) * 100)
res = N.times.count do
rooms = generate_rooms.call
prisoners.all? do |pr|
cur_room = pr
50.times.any? do
cur_room = rooms[cur_room - 1]
found = (cur_room == pr)
found
end
end
end
puts "Optimal strategy: %11.4f %%" % (res.fdiv(N) * 100) |
http://rosettacode.org/wiki/Abundant_odd_numbers | Abundant odd numbers | An Abundant number is a number n for which the sum of divisors σ(n) > 2n,
or, equivalently, the sum of proper divisors (or aliquot sum) s(n) > n.
E.G.
12 is abundant, it has the proper divisors 1,2,3,4 & 6 which sum to 16 ( > 12 or n);
or alternately, has the sigma sum of 1,2,3,4,6 & 12 which sum to 28 ( > 24 or 2n).
Abundant numbers are common, though even abundant numbers seem to be much more common than odd abundant numbers.
To make things more interesting, this task is specifically about finding odd abundant numbers.
Task
Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.
Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.
Find and display here: the first abundant odd number greater than one billion (109) and either its proper divisor sum or sigma sum.
References
OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)
American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)
| #Visual_Basic_.NET | Visual Basic .NET | Module AbundantOddNumbers
' find some abundant odd numbers - numbers where the sum of the proper
' divisors is bigger than the number
' itself
' returns the sum of the proper divisors of n
Private Function divisorSum(n As Integer) As Integer
Dim sum As Integer = 1
For d As Integer = 2 To Math.Round(Math.Sqrt(n))
If n Mod d = 0 Then
sum += d
Dim otherD As Integer = n \ d
IF otherD <> d Then
sum += otherD
End If
End If
Next d
Return sum
End Function
' find numbers required by the task
Public Sub Main(args() As String)
' first 25 odd abundant numbers
Dim oddNumber As Integer = 1
Dim aCount As Integer = 0
Dim dSum As Integer = 0
Console.Out.WriteLine("The first 25 abundant odd numbers:")
Do While aCount < 25
dSum = divisorSum(oddNumber)
If dSum > oddNumber Then
aCount += 1
Console.Out.WriteLine(oddNumber.ToString.PadLeft(6) & " proper divisor sum: " & dSum)
End If
oddNumber += 2
Loop
' 1000th odd abundant number
Do While aCount < 1000
dSum = divisorSum(oddNumber)
If dSum > oddNumber Then
aCount += 1
End If
oddNumber += 2
Loop
Console.Out.WriteLine("1000th abundant odd number:")
Console.Out.WriteLine(" " & (oddNumber - 2) & " proper divisor sum: " & dSum)
' first odd abundant number > one billion
oddNumber = 1000000001
Dim found As Boolean = False
Do While Not found
dSum = divisorSum(oddNumber)
If dSum > oddNumber Then
found = True
Console.Out.WriteLine("First abundant odd number > 1 000 000 000:")
Console.Out.WriteLine(" " & oddNumber & " proper divisor sum: " & dSum)
End If
oddNumber += 2
Loop
End Sub
End Module |
http://rosettacode.org/wiki/21_game | 21 game | 21 game
You are encouraged to solve this task according to the task description, using any language you may know.
21 is a two player game, the game is played by choosing
a number (1, 2, or 3) to be added to the running total.
The game is won by the player whose chosen number causes the running total
to reach exactly 21.
The running total starts at zero.
One player will be the computer.
Players alternate supplying a number to be added to the running total.
Task
Write a computer program that will:
do the prompting (or provide a button menu),
check for errors and display appropriate error messages,
do the additions (add a chosen number to the running total),
display the running total,
provide a mechanism for the player to quit/exit/halt/stop/close the program,
issue a notification when there is a winner, and
determine who goes first (maybe a random or user choice, or can be specified when the game begins).
| #Python | Python |
from random import randint
def start():
game_count=0
print("Enter q to quit at any time.\nThe computer will choose first.\nRunning total is now {}".format(game_count))
roundno=1
while game_count<21:
print("\nROUND {}: \n".format(roundno))
t = select_count(game_count)
game_count = game_count+t
print("Running total is now {}\n".format(game_count))
if game_count>=21:
print("So, commiserations, the computer has won!")
return 0
t = request_count()
if not t:
print('OK,quitting the game')
return -1
game_count = game_count+t
print("Running total is now {}\n".format(game_count))
if game_count>=21:
print("So, congratulations, you've won!")
return 1
roundno+=1
def select_count(game_count):
'''selects a random number if the game_count is less than 18. otherwise chooses the winning number'''
if game_count<18:
t= randint(1,3)
else:
t = 21-game_count
print("The computer chooses {}".format(t))
return t
def request_count():
'''request user input between 1,2 and 3. It will continue till either quit(q) or one of those numbers is requested.'''
t=""
while True:
try:
t = raw_input('Your choice 1 to 3 :')
if int(t) in [1,2,3]:
return int(t)
else:
print("Out of range, try again")
except:
if t=="q":
return None
else:
print("Invalid Entry, try again")
c=0
m=0
r=True
while r:
o = start()
if o==-1:
break
else:
c+=1 if o==0 else 0
m+=1 if o==1 else 0
print("Computer wins {0} game, human wins {1} games".format(c,m))
t = raw_input("Another game?(press y to continue):")
r = (t=="y") |
http://rosettacode.org/wiki/24_game/Solve | 24 game/Solve | task
Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the 24 game.
Show examples of solutions generated by the program.
Related task
Arithmetic Evaluator
| #GAP | GAP | # Solution in '''RPN'''
check := function(x, y, z)
local r, c, s, i, j, k, a, b, p;
i := 0;
j := 0;
k := 0;
s := [ ];
r := "";
for c in z do
if c = 'x' then
i := i + 1;
k := k + 1;
s[k] := x[i];
Append(r, String(x[i]));
else
j := j + 1;
b := s[k];
k := k - 1;
a := s[k];
p := y[j];
r[Size(r) + 1] := p;
if p = '+' then
a := a + b;
elif p = '-' then
a := a - b;
elif p = '*' then
a := a * b;
elif p = '/' then
if b = 0 then
continue;
else
a := a / b;
fi;
else
return fail;
fi;
s[k] := a;
fi;
od;
if s[1] = 24 then
return r;
else
return fail;
fi;
end;
Player24 := function(digits)
local u, v, w, x, y, z, r;
u := PermutationsList(digits);
v := Tuples("+-*/", 3);
w := ["xx*x*x*", "xx*xx**", "xxx**x*", "xxx*x**", "xxxx***"];
for x in u do
for y in v do
for z in w do
r := check(x, y, z);
if r <> fail then
return r;
fi;
od;
od;
od;
return fail;
end;
Player24([1,2,7,7]);
# "77*1-2/"
Player24([9,8,7,6]);
# "68*97-/"
Player24([1,1,7,7]);
# fail
# Solutions with only one distinct digit are found only for 3, 4, 5, 6:
Player24([3,3,3,3]);
# "33*3*3-"
Player24([4,4,4,4]);
# "44*4+4+"
Player24([5,5,5,5]);
# "55*55/-"
Player24([6,6,6,6]);
# "66*66+-"
# A tricky one:
Player24([3,3,8,8]);
"8383/-/" |
http://rosettacode.org/wiki/15_puzzle_game | 15 puzzle game |
Task
Implement the Fifteen Puzzle Game.
The 15-puzzle is also known as:
Fifteen Puzzle
Gem Puzzle
Boss Puzzle
Game of Fifteen
Mystic Square
14-15 Puzzle
and some others.
Related Tasks
15 Puzzle Solver
16 Puzzle Game
| #AArch64_Assembly | AArch64 Assembly |
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program puzzle15_64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ NBBOX, 16
.equ GRAINE, 123456 // change for other game
.equ NBSHUFFLE, 4
.equ KEYSIZE, 8
.equ IOCTL, 0x1D // Linux syscall
.equ SIGACTION, 0x86 // Linux syscall
.equ SYSPOLL, 0x16 // Linux syscall
.equ CREATPOLL, 0x14 // Linux syscall
.equ CTLPOLL, 0x15 // Linux syscall
.equ TCGETS, 0x5401
.equ TCSETS, 0x5402
.equ ICANON, 2
.equ ECHO, 10
.equ POLLIN, 1
.equ EPOLL_CTL_ADD, 1
.equ SIGINT, 2 // Issued if the user sends an interrupt signal (Ctrl + C)
.equ SIGQUIT, 3 // Issued if the user sends a quit signal (Ctrl + D)
.equ SIGTERM, 15 // Software termination signal (sent by kill by default)
.equ SIGTTOU, 22 //
/*******************************************/
/* Structures */
/********************************************/
/* structure termios see doc linux*/
.struct 0
term_c_iflag: // input modes
.struct term_c_iflag + 4
term_c_oflag: // output modes
.struct term_c_oflag + 4
term_c_cflag: // control modes
.struct term_c_cflag + 4
term_c_lflag: // local modes
.struct term_c_lflag + 4
term_c_cc: // special characters
.struct term_c_cc + 20 // see length if necessary
term_fin:
/* structure sigaction see doc linux */
.struct 0
sa_handler:
.struct sa_handler + 8
sa_mask:
.struct sa_mask + 8
sa_flags:
.struct sa_flags + 8
sa_sigaction:
.struct sa_sigaction + 8
sa_fin:
/* structure poll see doc linux */
.struct 0
poll_event:
.struct poll_event + 8
poll_fd: // File Descriptor
.struct poll_fd + 8
poll_fin:
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .ascii " "
sMessValeur: .fill 11, 1, ' ' // size => 11
szCarriageReturn: .asciz "\n"
szMessGameWin: .asciz "You win in @ move number !!!!\n"
szMessMoveError: .asciz "Huh... Impossible move !!!!\n"
szMessErreur: .asciz "Error detected.\n"
szMessErrInitTerm: .asciz "Error terminal init.\n"
szMessErrInitPoll: .asciz "Error poll init.\n"
szMessErreurKey: .asciz "Error read key.\n"
szMessSpaces: .asciz " "
qGraine: .quad GRAINE
szMessErr: .asciz "Error code hexa : @ décimal : @ \n"
szClear: .byte 0x1B
.byte 'c' // console clear
.byte 0
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
.align 4
sZoneConv: .skip 24
qCodeError: .skip 8
ibox: .skip 4 * NBBOX // game boxes
qEnd: .skip 8 // 0 loop 1 = end loop
qTouche: .skip KEYSIZE // value key pressed
stOldtio: .skip term_fin // old terminal state
stCurtio: .skip term_fin // current terminal state
stSigAction: .skip sa_fin // area signal structure
stSigAction1: .skip sa_fin
stSigAction2: .skip sa_fin
stSigAction3: .skip sa_fin
stPoll1: .skip poll_fin // area poll structure
stPoll2: .skip poll_fin
stevents: .skip 16
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
mov x0,#0
bl initTerm // terminal init
cmp x0,0 // error ?
blt 100f
bl initPoll // epoll instance init
cmp x0,0
blt 99f
mov x22,x0 // save epfd
ldr x2,qAdribox
mov x9,#0 // init counter
mov x0,0
1: // loop init boxs
add x1,x0,#1 // box value
str w1,[x2,x0, lsl #2] // store value
add x0,x0,#1 // increment counter
cmp x0,#NBBOX - 2 // end ?
ble 1b
mov x10,#15 // empty box location
ldr x0,qAdribox
bl shuffleGame
2: // loop moves
ldr x0,qAdribox
bl displayGame
3:
mov x0,x22 // epfd
bl waitKey
cmp x0,0
beq 3b // no ket pressed -> loop
blt 99f // error ?
bl readKey // read key
cmp x0,#-1
beq 99f // error
cmp x0,3 // <ctrl_C>
beq 5f
cmp x0,113 // saisie q (quit) ?
beq 5f
cmp x0,81 // saisie Q (Quit)?
beq 5f
mov x1,x0 // key
ldr x0,qAdribox
bl keyMove // analyze key move
ldr x0,qAdribox
bl gameOK // end game ?
cmp x0,#1
bne 2b // no -> loop
// win
mov x0,x9 // move counter
ldr x1,qAdrsZoneConv
bl conversion10
ldr x0,qAdrszMessGameWin
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at @ character
bl affichageMess
5:
bl restauTerm // terminal restaur
mov x0, #0 // return code
b 100f
99:
bl restauTerm // terminal restaur
mov x0,1 // return code error
b 100f
100: // standard end of the program
mov x8, #EXIT // request to exit program
svc #0 // perform the system call
qAdrsMessValeur: .quad sMessValeur
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsMessResult: .quad sMessResult
qAdribox: .quad ibox
qAdrszMessGameWin: .quad szMessGameWin
qAdrstevents: .quad stevents
qAdrszMessErreur: .quad szMessErreur
qAdrstOldtio: .quad stOldtio
qAdrstCurtio: .quad stCurtio
qAdrstSigAction: .quad stSigAction
qAdrstSigAction1: .quad stSigAction1
qAdrSIG_IGN: .quad 1
qAdrqEnd: .quad qEnd
qAdrqTouche: .quad qTouche
qAdrszMessErrInitTerm: .quad szMessErrInitTerm
qAdrszMessErrInitPoll: .quad szMessErrInitPoll
qAdrszMessErreurKey: .quad szMessErreurKey
/******************************************************************/
/* key move */
/******************************************************************/
/* x0 contains boxs address */
/* x1 contains key value */
/* x9 move counter */
/* x10 contains location empty box */
keyMove:
stp x1,lr,[sp,-16]! // save registers
mov x7,x0
lsr x1,x1,16
cmp x1,#0x42 // down arrow
bne 1f
cmp x10,#4 // if x10 < 4 error
blt 80f
sub x2,x10,#4 // compute location
b 90f
1:
cmp x1,#0x41 // high arrow
bne 2f
cmp x10,#11 // if x10 > 11 error
bgt 80f
add x2,x10,#4 // compute location
b 90f
2:
cmp x1,#0x43 // right arrow
bne 3f
tst x10,#0b11 // if x10 = 0,4,8,12 error
beq 80f
sub x2,x10,#1 // compute location
b 90f
3:
cmp x1,#0x44 // left arrow
bne 100f
and x3,x10,#0b11 // error if x10 = 3 7 11 and 15
cmp x3,#3
beq 80f
add x2,x10,#1 // compute location
b 90f
80: // move error
ldr x0,qAdrqCodeError
mov x1,#1
str x1,[x0]
b 100f
90: // white box and move box inversion
ldr w3,[x7,x2,lsl #2]
str w3,[x7,x10,lsl #2]
mov x10,x2
mov x3,#0
str w3,[x7,x10,lsl #2]
add x9,x9,#1 // increment move counter
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrqCodeError: .quad qCodeError
/******************************************************************/
/* shuffle game */
/******************************************************************/
/* x0 contains boxs address */
shuffleGame:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
stp x4,x5,[sp,-16]! // save registers
mov x1,x0
mov x0,NBSHUFFLE
bl genereraleas
lsl x4,x0,#1
1:
mov x0,#14
bl genereraleas
add x3,x0,#1
mov x0,#14
bl genereraleas
add x5,x0,#1
ldr w2,[x1,x3,lsl #2]
ldr w0,[x1,x5,lsl #2]
str w2,[x1,x5,lsl #2]
str w0,[x1,x3,lsl #2]
subs x4,x4,#1
bgt 1b
100:
ldp x4,x5,[sp],16 // restaur 2 registers
ldp x2,x3,[sp],16 // restaur 2 registers
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* game Ok ? */
/******************************************************************/
/* x0 contains boxs address */
gameOK:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
mov x2,#0
ldr w3,[x0,x2,lsl #2]
add x2,x2,#1
1:
ldr w1,[x0,x2,lsl #2]
cmp w1,w3
bge 2f
mov x0,#0 // game not Ok
b 100f
2:
mov x3,x1
add x2,x2,#1
cmp x2,#NBBOX -2
ble 1b
mov x0,#1 // game Ok
100:
ldp x2,x3,[sp],16 // restaur 2 registers
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/******************************************************************/
/* display game */
/******************************************************************/
/* x0 contains boxs address */
displayGame:
stp x1,lr,[sp,-16]! // save registers
// clear screen !
mov x4,x0
ldr x0,qAdrszClear
bl affichageMess
mov x2,#0
ldr x1,qAdrsMessValeur
1:
ldr w0,[x4,x2,lsl #2]
cmp w0,#0
bne 2f
ldr w0,iSpaces // store spaces
str w0,[x1]
b 3f
2:
bl conversion10 // call conversion decimal
cmp x0,1
beq 21f
mov x0,0x20
strh w0,[x1,#2]
b 3f
21:
mov w0,0x2020
str w0,[x1,#1]
3:
ldr x0,qAdrsMessResult
bl affichageMess // display message
add x0,x2,#1
tst x0,#0b11
bne 4f
ldr x0,qAdrszCarriageReturn
bl affichageMess // display message
4:
add x2,x2,#1
cmp x2,#NBBOX - 1
ble 1b
ldr x0,qAdrszCarriageReturn
bl affichageMess // display line return
ldr x0,qAdrqCodeError // error detected ?
ldr x1,[x0]
cmp x1,#0
beq 100f
mov x1,#0 // raz error code
str x1,[x0]
ldr x0,qAdrszMessMoveError // display error message
bl affichageMess
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
iSpaces: .int 0x00202020 // spaces
qAdrszClear: .quad szClear
qAdrszMessMoveError: .quad szMessMoveError
/***************************************************/
/* Generation random number */
/***************************************************/
/* x0 contains limit */
genereraleas:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
ldr x1,qAdrqGraine
ldr x2,[x1]
ldr x3,qNbDep1
mul x2,x3,x2
ldr x3,qNbDep2
add x2,x2,x3
str x2,[x1] // maj de la graine pour l appel suivant
cmp x0,#0
beq 100f
udiv x3,x2,x0
msub x0,x3,x0,x2 // résult = remainder
100: // end function
ldp x2,x3,[sp],16 // restaur 2 registers
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/*****************************************************/
qAdrqGraine: .quad qGraine
qNbDep1: .quad 0x0019660d
qNbDep2: .quad 0x3c6ef35f
/******************************************************************/
/* traitement du signal */
/******************************************************************/
sighandler:
stp x0,lr,[sp,-16]! // save registers
str x1,[sp,-16]!
ldr x0,qAdrqEnd
mov x1,#1 // maj zone end
str x1,[x0]
ldr x1,[sp],16
ldp x0,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/***************************************************/
/* display error message */
/***************************************************/
/* x0 contains error code x1 : message address */
displayError:
stp x2,lr,[sp,-16]! // save registers
mov x2,x0 // save error code
mov x0,x1
bl affichageMess
mov x0,x2 // error code
ldr x1,qAdrsZoneConv
bl conversion16 // conversion hexa
ldr x0,qAdrszMessErr // display error message
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at @ character
mov x3,x0
mov x0,x2 // error code
ldr x1,qAdrsZoneConv // result address
bl conversion10S // conversion decimale
mov x0,x3
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at @ character
bl affichageMess
100:
ldp x2,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrszMessErr: .quad szMessErr
qAdrsZoneConv: .quad sZoneConv
/*********************************/
/* init terminal state */
/*********************************/
initTerm:
stp x1,lr,[sp,-16]! // save registers
/* read terminal state */
mov x0,STDIN // input console
mov x1,TCGETS
ldr x2,qAdrstOldtio
mov x8,IOCTL // call system Linux
svc 0
cbnz x0,98f // error ?
adr x0,sighandler // adresse routine traitement signal
ldr x1,qAdrstSigAction // adresse structure sigaction
str x0,[x1,sa_handler] // maj handler
mov x0,SIGINT // signal type
ldr x1,qAdrstSigAction
mov x2,0
mov x3,8
mov x8,SIGACTION // call system
svc 0
cmp x0,0 // error ?
bne 98f
mov x0,SIGQUIT
ldr x1,qAdrstSigAction
mov x2,0 // NULL
mov x8,SIGACTION // call system
svc 0
cmp x0,0 // error ?
bne 98f
mov x0,SIGTERM
ldr x1,qAdrstSigAction
mov x2,0 // NULL
mov x8,SIGACTION // appel systeme
svc 0
cmp x0,0
bne 98f
//
adr x0,qAdrSIG_IGN // address signal igonre function
ldr x1,qAdrstSigAction1
str x0,[x1,sa_handler]
mov x0,SIGTTOU //invalidate other process signal
ldr x1,qAdrstSigAction1
mov x2,0 // NULL
mov x8,SIGACTION // call system
svc 0
cmp x0,0
bne 98f
//
/* read terminal current state */
mov x0,STDIN
mov x1,TCGETS
ldr x2,qAdrstCurtio // address current termio
mov x8,IOCTL // call systeme
svc 0
cmp x0,0 // error ?
bne 98f
mov x2,ICANON | ECHO // no key pressed echo on display
mvn x2,x2 // and one key
ldr x1,qAdrstCurtio
ldr x3,[x1,#term_c_lflag]
and x3,x2,x2 // add flags
str x3,[x1,#term_c_lflag] // and store
mov x0,STDIN // maj terminal current state
mov x1,TCSETS
ldr x2,qAdrstCurtio
mov x8,IOCTL // call system
svc 0
cbz x0,100f
98: // error display
ldr x1,qAdrszMessErrInitTerm
bl displayError
mov x0,-1
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrstSigAction2: .quad stSigAction2
qAdrstSigAction3: .quad stSigAction3
/*********************************/
/* init instance epool */
/*********************************/
initPoll:
stp x1,lr,[sp,-16]! // save registers
ldr x0,qAdrstevents
mov x1,STDIN // maj structure events
str x1,[x0,#poll_fd] // maj FD
mov x1,POLLIN // action code
str x1,[x0,#poll_event]
mov x0,0
mov x8,CREATPOLL // create epoll instance
svc 0
cmp x0,0 // error ?
ble 98f
mov x10,x0 // return FD epoll instance
mov x1,EPOLL_CTL_ADD
mov x2,STDIN // Fd to we want add
ldr x3,qAdrstevents // structure events address
mov x8,CTLPOLL // call system control epoll
svc 0
cmp x0,0 // error ?
blt 98f // no
mov x0,x10 // return FD epoll instance
b 100f
98: // error display
ldr x1,qAdrszMessErrInitPoll // error message
bl displayError
mov x0,-1
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/*********************************/
/* wait key */
/*********************************/
/* x0 contains FD poll */
waitKey:
stp x1,lr,[sp,-16]! // save registers
ldr x11,qAdrqTouche // key address
str xzr,[x11] // raz key
1:
ldr x1,qAdrqEnd // if signal ctrl-c -> end
ldr x1,[x1]
cbnz x1,100f
ldr x1,qAdrstevents
mov x2,12 // size events
mov x3,1 // timeout = 1 TODO: ??
mov x4,0
mov x8,SYSPOLL // call system wait POLL
svc 0
cmp x0,0 // key pressed ?
bge 100f
98: // error display
ldr x1,qAdrszMessErreurKey // error message
bl displayError
mov x0,-1
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/*********************************/
/* read key */
/*********************************/
/* x0 returns key value */
readKey:
stp x1,lr,[sp,-16]! // save registers
mov x0,STDIN // File Descriptor
ldr x1,qAdrqTouche // buffer address
mov x2,KEYSIZE // key size
mov x8,READ // read key
svc #0
cmp x0,0 // error ?
ble 98f
ldr x2,qAdrqTouche // key address
ldr x0,[x2]
b 100f
98: // error display
ldr x1,qAdrszMessErreur // error message
bl displayError
mov x0,-1
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/*********************************/
/* restaur terminal state */
/*********************************/
restauTerm:
stp x1,lr,[sp,-16]! // save registers
mov x0,STDIN // end then restaur begin state terminal
mov x1,TCSETS
ldr x2,qAdrstOldtio
mov x8,IOCTL // call system
svc 0
cbz x0,100f
ldr x1,qAdrszMessErreur // error message
bl displayError
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
|
http://rosettacode.org/wiki/2048 | 2048 | Task
Implement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.
Rules of the game
The rules are that on each turn the player must choose a direction (up, down, left or right).
All tiles move as far as possible in that direction, some move more than others.
Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.
A move is valid when at least one tile can be moved, if only by combination.
A new tile with the value of 2 is spawned at the end of each turn at a randomly chosen empty square (if there is one).
Adding a new tile on a blank space. Most of the time, a new 2 is to be added, and occasionally (10% of the time), a 4.
To win, the player must create a tile with the number 2048.
The player loses if no valid moves are possible.
The name comes from the popular open-source implementation of this game mechanic, 2048.
Requirements
"Non-greedy" movement.
The tiles that were created by combining other tiles should not be combined again during the same turn (move).
That is to say, that moving the tile row of:
[2][2][2][2]
to the right should result in:
......[4][4]
and not:
.........[8]
"Move direction priority".
If more than one variant of combining is possible, move direction shall indicate which combination will take effect.
For example, moving the tile row of:
...[2][2][2]
to the right should result in:
......[2][4]
and not:
......[4][2]
Check for valid moves. The player shouldn't be able to skip their turn by trying a move that doesn't change the board.
Check for a win condition.
Check for a lose condition.
| #Batch_File | Batch File | :: 2048 Game Task from RosettaCode
:: Batch File Implementation v2.0.1
@echo off
setlocal enabledelayedexpansion
rem initialization
:begin_game
set "size=4" %== board size ==%
set "score=0" %== current score ==%
set "won=0" %== boolean for winning ==%
set "target=2048" %== as the game title says ==%
for /l %%R in (1,1,%size%) do for /l %%C in (1,1,%size%) do set "X_%%R_%%C=0"
rem add two numbers in the board
call :addtile
call :addtile
rem main game loop
:main_loop
call :display
echo(
echo(Keys: WASD (Slide Movement), N (New game), P (Exit)
rem get keypress trick
set "key="
for /f "delims=" %%? in ('xcopy /w "%~f0" "%~f0" 2^>nul') do if not defined key set "key=%%?"
set "key=%key:~-1%"
set "changed=0" %== boolean for changed board ==%
set "valid_key=0" %== boolean for pressing WASD ==%
rem process keypress
if /i "!key!" equ "W" (set "valid_key=1" & call :slide "C" "1,1,%size%" "X")
if /i "!key!" equ "A" (set "valid_key=1" & call :slide "R" "1,1,%size%" "X")
if /i "!key!" equ "S" (set "valid_key=1" & call :slide "C" "%size%,-1,1" "X")
if /i "!key!" equ "D" (set "valid_key=1" & call :slide "R" "%size%,-1,1" "X")
if /i "!key!" equ "N" goto begin_game
if /i "!key!" equ "P" exit /b 0
if "%valid_key%" equ "0" goto main_loop
rem check if the board changed
if %changed% neq 0 call :addtile
rem check for win condition
if %won% equ 1 (
set "msg=Nice one... You WON^!^!"
goto gameover
)
rem check for lose condition
if %blank_count% equ 0 (
for /l %%R in (1,1,%size%) do for /l %%C in (1,1,%size%) do set "LX_%%R_%%C=!X_%%R_%%C!"
set "save_changed=%changed%" & set "changed=0" %== save actual changed for test ==%
call :slide "C" "1,1,%size%" "LX"
call :slide "R" "1,1,%size%" "LX"
if !changed! equ 0 (
set "msg=No moves are possible... Game Over :("
goto gameover
) else set "changed=!save_changed!"
)
goto main_loop
rem add number to a random blank tile
:addtile
set "blank_count=0" %== blank tile counter ==%
set "new_tile=" %== clearing ==%
rem create pseudo-array blank_tiles
for /l %%R in (1,1,%size%) do (
for /l %%C in (1,1,%size%) do (
if !X_%%R_%%C! equ 0 (
set "blank_tiles[!blank_count!]=X_%%R_%%C"
set /a "blank_count+=1"
)
)
)
if %blank_count% equ 0 goto :EOF
set /a "pick_tile=%random%%%%blank_count%"
set "new_tile=!blank_tiles[%pick_tile%]!"
set /a "rnd_newnum=%random%%%10"
rem 10% chance new number is 4, 90% chance it's 2
if %rnd_newnum% equ 5 (set "%new_tile%=4") else (set "%new_tile%=2")
set /a "blank_count-=1" %== to be used for checking lose condition ==%
goto :EOF
rem display the board
:display
cls
echo(2048 Game in Batch
echo(
set "wall=+"
for /l %%C in (1,1,%size%) do set "wall=!wall!----+"
for /l %%R in (1,1,%size%) do (
set "disp_row=|"
for /l %%C in (1,1,%size%) do (
if "!new_tile!" equ "X_%%R_%%C" (set "DX_%%R_%%C= +!X_%%R_%%C!") else (
set "DX_%%R_%%C=!X_%%R_%%C!"
if !X_%%R_%%C! lss 1000 set "DX_%%R_%%C= !DX_%%R_%%C!"
if !X_%%R_%%C! lss 100 set "DX_%%R_%%C= !DX_%%R_%%C!"
if !X_%%R_%%C! lss 10 set "DX_%%R_%%C= !DX_%%R_%%C!"
if !X_%%R_%%C! equ 0 set "DX_%%R_%%C= "
)
set "disp_row=!disp_row!!DX_%%R_%%C!|"
)
echo(%wall%
echo(!disp_row!
)
echo(%wall%
echo(
echo(Score: %score%
goto :EOF
rem the main slider of numbers in tiles
:slide
rem %%A and %%B are used here because sliding direction is variable
for /l %%A in (1,1,%size%) do (
rem first slide: removing blank tiles in the middle
set "slide_1="
set "last_blank=0" %== boolean if last tile is blank ==%
for /l %%B in (%~2) do (
if "%~1" equ "R" (set "curr_tilenum=!%~3_%%A_%%B!"
) else if "%~1" equ "C" (set "curr_tilenum=!%~3_%%B_%%A!")
if !curr_tilenum! equ 0 (set "last_blank=1") else (
set "slide_1=!slide_1! !curr_tilenum!"
if !last_blank! equ 1 set "changed=1"
set "last_blank=0"
)
)
rem second slide: addition of numbered tiles
rem slide_2 would be pseudo-array
set "slide_2_count=0"
set "skip=1" %== boolean for skipping after previous summing ==%
if "!slide_1!" neq "" for %%S in (!slide_1! 0) do (
if !skip! equ 1 (
set "prev_tilenum=%%S" & set "skip=0"
) else if !skip! equ 0 (
if %%S equ !prev_tilenum! (
set /a "sum=%%S+!prev_tilenum!"
if "%~3" equ "X" set /a "score+=sum"
set "changed=1" & set "skip=1"
rem check for winning condition!
if !sum! equ !target! set "won=1"
) else (
set "sum=!prev_tilenum!"
set "prev_tilenum=%%S"
)
set "slide_2[!slide_2_count!]=!sum!"
set /a "slide_2_count+=1"
)
)
rem new values of tiles
set "slide_2_run=0" %== running counter for slide_2 ==%
for /l %%B in (%~2) do (
if "%~1" equ "R" (set "curr_tile=%~3_%%A_%%B"
) else if "%~1" equ "C" (set "curr_tile=%~3_%%B_%%A")
for %%? in ("!slide_2_run!") do (
if %%~? lss !slide_2_count! (set "!curr_tile!=!slide_2[%%~?]!"
) else (set "!curr_tile!=0")
)
set /a "slide_2_run+=1"
)
)
goto :EOF
rem game over xD
:gameover
call :display
echo(
echo(!msg!
echo(
echo(Press any key to exit . . .
pause>nul
exit /b 0 |
http://rosettacode.org/wiki/4-rings_or_4-squares_puzzle | 4-rings or 4-squares puzzle | 4-rings or 4-squares puzzle
You are encouraged to solve this task according to the task description, using any language you may know.
Task
Replace a, b, c, d, e, f, and
g with the decimal
digits LOW ───► HIGH
such that the sum of the letters inside of each of the four large squares add up to
the same sum.
╔══════════════╗ ╔══════════════╗
║ ║ ║ ║
║ a ║ ║ e ║
║ ║ ║ ║
║ ┌───╫──────╫───┐ ┌───╫─────────┐
║ │ ║ ║ │ │ ║ │
║ │ b ║ ║ d │ │ f ║ │
║ │ ║ ║ │ │ ║ │
║ │ ║ ║ │ │ ║ │
╚══════════╪═══╝ ╚═══╪══════╪═══╝ │
│ c │ │ g │
│ │ │ │
│ │ │ │
└──────────────┘ └─────────────┘
Show all output here.
Show all solutions for each letter being unique with
LOW=1 HIGH=7
Show all solutions for each letter being unique with
LOW=3 HIGH=9
Show only the number of solutions when each letter can be non-unique
LOW=0 HIGH=9
Related task
Solve the no connection puzzle
| #R | R | # 4 rings or 4 squares puzzle
perms <- function (n, r, v = 1:n, repeats.allowed = FALSE) {
if (repeats.allowed)
sub <- function(n, r, v) {
if (r == 1)
matrix(v, n, 1)
else if (n == 1)
matrix(v, 1, r)
else {
inner <- Recall(n, r - 1, v)
cbind(rep(v, rep(nrow(inner), n)), matrix(t(inner),
ncol = ncol(inner), nrow = nrow(inner) * n,
byrow = TRUE))
}
}
else sub <- function(n, r, v) {
if (r == 1)
matrix(v, n, 1)
else if (n == 1)
matrix(v, 1, r)
else {
X <- NULL
for (i in 1:n) X <- rbind(X, cbind(v[i], Recall(n - 1, r - 1, v[-i])))
X
}
}
X <- sub(n, r, v[1:n])
result <- vector(mode = "numeric")
for(i in 1:nrow(X)){
y <- X[i, ]
x1 <- y[1] + y[2]
x2 <- y[2] + y[3] + y[4]
x3 <- y[4] + y[5] + y[6]
x4 <- y[6] + y[7]
if(x1 == x2 & x2 == x3 & x3 == x4) result <- rbind(result, y)
}
return(result)
}
print_perms <- function(n, r, v = 1:n, repeats.allowed = FALSE, table.out = FALSE) {
a <- perms(n, r, v, repeats.allowed)
colnames(a) <- rep("", ncol(a))
rownames(a) <- rep("", nrow(a))
if(!repeats.allowed){
print(a)
cat(paste('\n', nrow(a), 'unique solutions from', min(v), 'to', max(v)))
} else {
cat(paste('\n', nrow(a), 'non-unique solutions from', min(v), 'to', max(v)))
}
}
registerS3method("print_perms", "data.frame", print_perms)
print_perms(7, 7, repeats.allowed = FALSE, table.out = TRUE)
print_perms(7, 7, v = 3:9, repeats.allowed = FALSE, table.out = TRUE)
print_perms(10, 7, v = 0:9, repeats.allowed = TRUE, table.out = FALSE)
|
http://rosettacode.org/wiki/15_puzzle_solver | 15 puzzle solver | Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.
For this task you will be using the following puzzle:
15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
The output must show the moves' directions, like so: left, left, left, down, right... and so on.
There are two solutions, of fifty-two moves:
rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd
rrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd
see: Pretty Print of Optimal Solution
Finding either one, or both is an acceptable result.
Extra credit.
Solve the following problem:
0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1
Related Task
15 puzzle game
A* search algorithm
| #Forth | Forth |
#! /usr/bin/gforth
cell 8 <> [if] s" 64-bit system required" exception throw [then]
\ In the stack comments below,
\ "h" stands for the hole position (0..15),
\ "s" for a 64-bit integer representing a board state,
\ "t" a tile value (0..15, 0 is the hole),
\ "b" for a bit offset of a position within a state,
\ "m" for a masked value (4 bits selected out of a 64-bit state),
\ "w" for a weight of a current path,
\ "d" for a direction constant (0..3)
\ Utility
: 3dup 2 pick 2 pick 2 pick ;
: 4dup 2over 2over ;
: shift dup 0 > if lshift else negate rshift then ;
hex 123456789abcdef0 decimal constant solution
: row 2 rshift ; : col 3 and ;
: up-valid? ( h -- f ) row 0 > ;
: down-valid? ( h -- f ) row 3 < ;
: left-valid? ( h -- f ) col 0 > ;
: right-valid? ( h -- f ) col 3 < ;
: up-cost ( h t -- 0|1 ) 1 - row swap row < 1 and ;
: down-cost ( h t -- 0|1 ) 1 - row swap row > 1 and ;
: left-cost ( h t -- 0|1 ) 1 - col swap col < 1 and ;
: right-cost ( h t -- 0|1 ) 1 - col swap col > 1 and ;
\ To iterate over all possible directions, put direction-related functions into arrays:
: ith ( u addr -- w ) swap cells + @ ;
create valid? ' up-valid? , ' left-valid? , ' right-valid? , ' down-valid? , does> ith execute ;
create cost ' up-cost , ' left-cost , ' right-cost , ' down-cost , does> ith execute ;
create step -4 , -1 , 1 , 4 , does> ith ;
\ Advance from a single state to another:
: bits ( h -- b ) 15 swap - 4 * ;
: tile ( s b -- t ) rshift 15 and ;
: new-state ( s h d -- s' ) step dup >r + bits 2dup tile ( s b t ) swap lshift tuck - swap r> 4 * shift + ;
: new-weight ( w s h d -- w' ) >r tuck r@ step + bits tile r> cost + ;
: advance ( w s h d -- w s h w' s' h' ) 4dup new-weight >r 3dup new-state >r step over + 2r> rot ;
\ Print a solution:
: rollback 2drop drop ;
: .dir ( u -- ) s" d..r.l..u" drop 4 + swap + c@ emit ;
: .dirs ( .. -- ) 0 begin >r 3 pick -1 <> while 3 pick over - .dir rollback r> 1+ repeat r> ;
: win cr ." solved (read right-to-left!): " .dirs ." - " . ." moves" bye ;
\ The main recursive function for depth-first search:
create limit 1 , : deeper 1 limit +! ;
: u-turn ( .. h2 w1 s1 h1 ) 4 pick 2 pick - ;
: search ( .. h2 w1 s1 h1 )
over solution = if win then
2 pick limit @ > if exit then
4 0 do dup i valid? if i step u-turn <> if i advance recurse rollback then then loop ;
\ Iterative-deepning search:
: solve 1 limit ! begin search deeper again ;
\ -1 0 hex 0c9dfbae37254861 decimal 0 solve \ uhm.
-1 0 hex fe169b4c0a73d852 decimal 8 solve \ the 52 moves case
\ -1 0 hex 123456789afbde0c decimal 14 solve \ some trivial case, 3 moves
bye
|
http://rosettacode.org/wiki/99_bottles_of_beer | 99 bottles of beer | Task
Display the complete lyrics for the song: 99 Bottles of Beer on the Wall.
The beer song
The lyrics follow this form:
99 bottles of beer on the wall
99 bottles of beer
Take one down, pass it around
98 bottles of beer on the wall
98 bottles of beer on the wall
98 bottles of beer
Take one down, pass it around
97 bottles of beer on the wall
... and so on, until reaching 0 (zero).
Grammatical support for 1 bottle of beer is optional.
As with any puzzle, try to do it in as creative/concise/comical a way
as possible (simple, obvious solutions allowed, too).
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
See also
http://99-bottles-of-beer.net/
Category:99_Bottles_of_Beer
Category:Programming language families
Wikipedia 99 bottles of beer
| #Apex | Apex |
for(Integer i = 99; i=0; i--){
system.debug(i + ' bottles of beer on the wall');
system.debug('\n');
system.debug(i + ' bottles of beer on the wall');
system.debug(i + ' bottles of beer');
system.debug('take one down, pass it around');
}
|
http://rosettacode.org/wiki/24_game | 24 game | The 24 Game tests one's mental arithmetic.
Task
Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
The goal is for the player to enter an expression that (numerically) evaluates to 24.
Only the following operators/functions are allowed: multiplication, division, addition, subtraction
Division should use floating point or rational arithmetic, etc, to preserve remainders.
Brackets are allowed, if using an infix expression evaluator.
Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
The order of the digits when given does not have to be preserved.
Notes
The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
The task is not for the program to generate the expression, or test whether an expression is even possible.
Related tasks
24 game/Solve
Reference
The 24 Game on h2g2.
| #Elena | Elena | import system'routines;
import system'collections;
import system'dynamic;
import extensions;
// --- Expression ---
class ExpressionTree
{
object theTree;
constructor(s)
{
auto level := new Integer(0);
s.forEach:(ch)
{
var node := new DynamicStruct();
ch =>
$43 { node.Level := level + 1; node.Operation := __subj add } // +
$45 { node.Level := level + 1; node.Operation := __subj subtract } // -
$42 { node.Level := level + 2; node.Operation := __subj multiply } // *
$47 { node.Level := level + 2; node.Operation := __subj divide } // /
$40 { level.append(10); ^ self } // (
$41 { level.reduce(10); ^ self } // )
: {
node.Leaf := ch.toString().toReal();
node.Level := level + 3
};
if (nil == theTree)
{
theTree := node
}
else
{
if (theTree.Level >= node.Level)
{
node.Left := theTree;
node.Right := nilValue;
theTree := node
}
else
{
var top := theTree;
while ((nilValue != top.Right)&&(top.Right.Level < node.Level))
{ top := top.Right };
node.Left := top.Right;
node.Right := nilValue;
top.Right := node
}
}
}
}
eval(node)
{
if (node.containsProperty(subjconst Leaf))
{
^ node.Leaf
}
else
{
var left := self.eval(node.Left);
var right := self.eval(node.Right);
var op := node.Operation;
^ op(left, right);
}
}
get Value()
<= eval(theTree);
readLeaves(list, node)
{
if (nil == node)
{ InvalidArgumentException.raise() };
if (node.containsProperty(subjconst Leaf))
{
list.append(node.Leaf)
}
else
{
self.readLeaves(list, node.Left);
self.readLeaves(list, node.Right)
}
}
readLeaves(list)
<= readLeaves(list,theTree);
}
// --- Game ---
class TwentyFourGame
{
object theNumbers;
constructor()
{
self.newPuzzle();
}
newPuzzle()
{
theNumbers := new object[]
{
1 + randomGenerator.eval:9,
1 + randomGenerator.eval:9,
1 + randomGenerator.eval:9,
1 + randomGenerator.eval:9
}
}
help()
{
console
.printLine:"------------------------------- Instructions ------------------------------"
.printLine:"Four digits will be displayed."
.printLine:"Enter an equation using all of those four digits that evaluates to 24"
.printLine:"Only * / + - operators and () are allowed"
.printLine:"Digits can only be used once, but in any order you need."
.printLine:"Digits cannot be combined - i.e.: 12 + 12 when given 1,2,2,1 is not allowed"
.printLine:"Submit a blank line to skip the current puzzle."
.printLine:"Type 'q' to quit"
.writeLine()
.printLine:"Example: given 2 3 8 2, answer should resemble 8*3-(2-2)"
.printLine:"------------------------------- --------------------------------------------"
}
prompt()
{
theNumbers.forEach:(n){ console.print(n," ") };
console.print:": "
}
resolve(expr)
{
var tree := new ExpressionTree(expr);
var leaves := new ArrayList();
tree.readLeaves:leaves;
ifnot (leaves.ascendant().sequenceEqual(theNumbers.ascendant()))
{ console.printLine:"Invalid input. Enter an equation using all of those four digits. Try again."; ^ self };
var result := tree.Value;
if (result == 24)
{
console.printLine("Good work. ",expr,"=",result);
self.newPuzzle()
}
else
{
console.printLine("Incorrect. ",expr,"=",result)
}
}
}
extension gameOp
{
playRound(expr)
{
if (expr == "q")
{
^ false
}
else
{
if (expr == "")
{
console.printLine:"Skipping this puzzle"; self.newPuzzle()
}
else
{
try
{
self.resolve(expr)
}
catch(Exception e)
{
console.printLine:"An error occurred. Check your input and try again."
}
};
^ true
}
}
}
public program()
{
var game := new TwentyFourGame().help();
while (game.prompt().playRound(console.readLine())) {}
} |
http://rosettacode.org/wiki/A%2BB | A+B | A+B ─── a classic problem in programming contests, it's given so contestants can gain familiarity with the online judging system being used.
Task
Given two integers, A and B.
Their sum needs to be calculated.
Input data
Two integers are written in the input stream, separated by space(s):
(
−
1000
≤
A
,
B
≤
+
1000
)
{\displaystyle (-1000\leq A,B\leq +1000)}
Output data
The required output is one integer: the sum of A and B.
Example
input
output
2 2
4
3 2
5
| #Clojure | Clojure | (println (+ (Integer/parseInt (read-line)) (Integer/parseInt (read-line))))
3
4
=>7 |
http://rosettacode.org/wiki/Ackermann_function | Ackermann function | The Ackermann function is a classic example of a recursive function, notable especially because it is not a primitive recursive function. It grows very quickly in value, as does the size of its call tree.
The Ackermann function is usually defined as follows:
A
(
m
,
n
)
=
{
n
+
1
if
m
=
0
A
(
m
−
1
,
1
)
if
m
>
0
and
n
=
0
A
(
m
−
1
,
A
(
m
,
n
−
1
)
)
if
m
>
0
and
n
>
0.
{\displaystyle A(m,n)={\begin{cases}n+1&{\mbox{if }}m=0\\A(m-1,1)&{\mbox{if }}m>0{\mbox{ and }}n=0\\A(m-1,A(m,n-1))&{\mbox{if }}m>0{\mbox{ and }}n>0.\end{cases}}}
Its arguments are never negative and it always terminates.
Task
Write a function which returns the value of
A
(
m
,
n
)
{\displaystyle A(m,n)}
. Arbitrary precision is preferred (since the function grows so quickly), but not required.
See also
Conway chained arrow notation for the Ackermann function.
| #UNIX_Shell | UNIX Shell | ack() {
local m=$1
local n=$2
if [ $m -eq 0 ]; then
echo -n $((n+1))
elif [ $n -eq 0 ]; then
ack $((m-1)) 1
else
ack $((m-1)) $(ack $m $((n-1)))
fi
} |
http://rosettacode.org/wiki/ABC_problem | ABC problem | ABC problem
You are encouraged to solve this task according to the task description, using any language you may know.
You are given a collection of ABC blocks (maybe like the ones you had when you were a kid).
There are twenty blocks with two letters on each block.
A complete alphabet is guaranteed amongst all sides of the blocks.
The sample collection of blocks:
(B O)
(X K)
(D Q)
(C P)
(N A)
(G T)
(R E)
(T G)
(Q D)
(F S)
(J W)
(H U)
(V I)
(A N)
(O B)
(E R)
(F S)
(L Y)
(P C)
(Z M)
Task
Write a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.
The rules are simple:
Once a letter on a block is used that block cannot be used again
The function should be case-insensitive
Show the output on this page for the following 7 words in the following example
Example
>>> can_make_word("A")
True
>>> can_make_word("BARK")
True
>>> can_make_word("BOOK")
False
>>> can_make_word("TREAT")
True
>>> can_make_word("COMMON")
False
>>> can_make_word("SQUAD")
True
>>> can_make_word("CONFUSE")
True
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
| #Forth | Forth | : blockslist s" BOXKDQCPNAGTRETGQDFSJWHUVIANOBERFSLYPCZM" ;
variable blocks
: allotblocks ( -- ) here blockslist dup allot here over - swap move blocks ! ;
: freeblocks blockslist nip negate allot ;
: toupper 223 and ;
: clearblock ( addr-block -- )
dup '_' swap c!
dup blocks @ - 1 and if 1- else 1+ then
'_' swap c!
;
: pickblock ( addr-input -- addr-input+1 f )
dup 1+ swap c@ toupper ( -- addr-input+1 c )
blockslist nip 0 do
blocks @ i + dup c@ 2 pick ( -- addr-input+1 c addri ci c )
= if clearblock drop true unloop exit else drop then
loop drop false
;
: abc ( addr-input u -- f )
allotblocks
0 do
pickblock
invert if drop false unloop exit cr then
loop drop true
freeblocks
;
: .abc abc if ." True" else ." False" then ; |
http://rosettacode.org/wiki/100_prisoners | 100 prisoners |
The Problem
100 prisoners are individually numbered 1 to 100
A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.
Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.
Prisoners start outside the room
They can decide some strategy before any enter the room.
Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.
A prisoner can open no more than 50 drawers.
A prisoner tries to find his own number.
A prisoner finding his own number is then held apart from the others.
If all 100 prisoners find their own numbers then they will all be pardoned. If any don't then all sentences stand.
The task
Simulate several thousand instances of the game where the prisoners randomly open drawers
Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:
First opening the drawer whose outside number is his prisoner number.
If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).
Show and compare the computed probabilities of success for the two strategies, here, on this page.
References
The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).
wp:100 prisoners problem
100 Prisoners Escape Puzzle DataGenetics.
Random permutation statistics#One hundred prisoners on Wikipedia.
| #D | D | import std.array;
import std.random;
import std.range;
import std.stdio;
import std.traits;
bool playOptimal() {
auto secrets = iota(100).array.randomShuffle();
prisoner:
foreach (p; 0..100) {
auto choice = p;
foreach (_; 0..50) {
if (secrets[choice] == p) continue prisoner;
choice = secrets[choice];
}
return false;
}
return true;
}
bool playRandom() {
auto secrets = iota(100).array.randomShuffle();
prisoner:
foreach (p; 0..100) {
auto choices = iota(100).array.randomShuffle();
foreach (i; 0..50) {
if (choices[i] == p) continue prisoner;
}
return false;
}
return true;
}
double exec(const size_t n, bool function() play) {
size_t success = 0;
for (int i = n; i > 0; i--) {
if (play()) {
success++;
}
}
return 100.0 * success / n;
}
void main() {
enum N = 1_000_000;
writeln("# of executions: ", N);
writefln("Optimal play success rate: %11.8f%%", exec(N, &playOptimal));
writefln(" Random play success rate: %11.8f%%", exec(N, &playRandom));
} |
http://rosettacode.org/wiki/Abundant_odd_numbers | Abundant odd numbers | An Abundant number is a number n for which the sum of divisors σ(n) > 2n,
or, equivalently, the sum of proper divisors (or aliquot sum) s(n) > n.
E.G.
12 is abundant, it has the proper divisors 1,2,3,4 & 6 which sum to 16 ( > 12 or n);
or alternately, has the sigma sum of 1,2,3,4,6 & 12 which sum to 28 ( > 24 or 2n).
Abundant numbers are common, though even abundant numbers seem to be much more common than odd abundant numbers.
To make things more interesting, this task is specifically about finding odd abundant numbers.
Task
Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.
Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.
Find and display here: the first abundant odd number greater than one billion (109) and either its proper divisor sum or sigma sum.
References
OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)
American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)
| #Vlang | Vlang | fn divisors(n i64) []i64 {
mut divs := [i64(1)]
mut divs2 := []i64{}
for i := 2; i*i <= n; i++ {
if n%i == 0 {
j := n / i
divs << i
if i != j {
divs2 << j
}
}
}
for i := divs2.len - 1; i >= 0; i-- {
divs << divs2[i]
}
return divs
}
fn sum(divs []i64) i64 {
mut tot := i64(0)
for div in divs {
tot += div
}
return tot
}
fn sum_str(divs []i64) string {
mut s := ""
for div in divs {
s += "${u8(div)} + "
}
return s[0..s.len-3]
}
fn abundant_odd(search_from i64, count_from int, count_to int, print_one bool) i64 {
mut count := count_from
mut n := search_from
for ; count < count_to; n += 2 {
divs := divisors(n)
tot := sum(divs)
if tot > n {
count++
if print_one && count < count_to {
continue
}
s := sum_str(divs)
if !print_one {
println("${count:2}. ${n:5} < $s = $tot")
} else {
println("$n < $s = $tot")
}
}
}
return n
}
const max = 25
fn main() {
println("The first $max abundant odd numbers are:")
n := abundant_odd(1, 0, 25, false)
println("\nThe one thousandth abundant odd number is:")
abundant_odd(n, 25, 1000, true)
println("\nThe first abundant odd number above one billion is:")
abundant_odd(1_000_000_001, 0, 1, true)
} |
http://rosettacode.org/wiki/21_game | 21 game | 21 game
You are encouraged to solve this task according to the task description, using any language you may know.
21 is a two player game, the game is played by choosing
a number (1, 2, or 3) to be added to the running total.
The game is won by the player whose chosen number causes the running total
to reach exactly 21.
The running total starts at zero.
One player will be the computer.
Players alternate supplying a number to be added to the running total.
Task
Write a computer program that will:
do the prompting (or provide a button menu),
check for errors and display appropriate error messages,
do the additions (add a chosen number to the running total),
display the running total,
provide a mechanism for the player to quit/exit/halt/stop/close the program,
issue a notification when there is a winner, and
determine who goes first (maybe a random or user choice, or can be specified when the game begins).
| #Quackery | Quackery | [ say
"Who goes first: Computer, Player"
say " or Random?" cr
[ $ "Enter C, P or R: " input
dup size 1 != iff drop again
0 peek
dup char C = iff [ drop 0 ] done
dup char P = iff [ drop 1 ] done
char R = iff [ 2 random ] done
again ]
cr
dup iff [ say "You go first." ]
else [ say "I will go first." ]
cr ] is chooseplayer ( --> n )
forward is player ( n --> n x )
[ [ dup 17 > iff 1 done
4 over 4 mod
dup 0 = if [ drop 3 ]
- ]
dup say "Computer chooses " echo
say "." cr
+ ' player ] is computer ( n --> n x )
[ say "Choose 1 2 or 3 (running "
$ "total must not exceed 21, Q to quit): " input
dup $ "Q" = iff [ drop 21 999 ] done
trim reverse trim reverse
$->n not iff drop again
dup 1 4 within not iff drop again
2dup + 21 > iff drop again
+ ' computer ] resolves player ( n --> n x )
[ say "The player who makes 21 loses." cr
0 chooseplayer
iff [ ' player ] else [ ' computer ]
[ say "Running total is "
over echo say "." cr cr
do
over 21 = until ]
cr
dup 999 = iff
[ drop 2drop say "Quitter!" ] done
' computer = iff
[ say "The computer won!" ]
else [ say "You won! Well done!" ]
drop ] is play ( --> ) |
http://rosettacode.org/wiki/24_game/Solve | 24 game/Solve | task
Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the 24 game.
Show examples of solutions generated by the program.
Related task
Arithmetic Evaluator
| #Go | Go | package main
import (
"fmt"
"math/rand"
"time"
)
const (
op_num = iota
op_add
op_sub
op_mul
op_div
)
type frac struct {
num, denom int
}
// Expression: can either be a single number, or a result of binary
// operation from left and right node
type Expr struct {
op int
left, right *Expr
value frac
}
var n_cards = 4
var goal = 24
var digit_range = 9
func (x *Expr) String() string {
if x.op == op_num {
return fmt.Sprintf("%d", x.value.num)
}
var bl1, br1, bl2, br2, opstr string
switch {
case x.left.op == op_num:
case x.left.op >= x.op:
case x.left.op == op_add && x.op == op_sub:
bl1, br1 = "", ""
default:
bl1, br1 = "(", ")"
}
if x.right.op == op_num || x.op < x.right.op {
bl2, br2 = "", ""
} else {
bl2, br2 = "(", ")"
}
switch {
case x.op == op_add:
opstr = " + "
case x.op == op_sub:
opstr = " - "
case x.op == op_mul:
opstr = " * "
case x.op == op_div:
opstr = " / "
}
return bl1 + x.left.String() + br1 + opstr +
bl2 + x.right.String() + br2
}
func expr_eval(x *Expr) (f frac) {
if x.op == op_num {
return x.value
}
l, r := expr_eval(x.left), expr_eval(x.right)
switch x.op {
case op_add:
f.num = l.num*r.denom + l.denom*r.num
f.denom = l.denom * r.denom
return
case op_sub:
f.num = l.num*r.denom - l.denom*r.num
f.denom = l.denom * r.denom
return
case op_mul:
f.num = l.num * r.num
f.denom = l.denom * r.denom
return
case op_div:
f.num = l.num * r.denom
f.denom = l.denom * r.num
return
}
return
}
func solve(ex_in []*Expr) bool {
// only one expression left, meaning all numbers are arranged into
// a binary tree, so evaluate and see if we get 24
if len(ex_in) == 1 {
f := expr_eval(ex_in[0])
if f.denom != 0 && f.num == f.denom*goal {
fmt.Println(ex_in[0].String())
return true
}
return false
}
var node Expr
ex := make([]*Expr, len(ex_in)-1)
// try to combine a pair of expressions into one, thus reduce
// the list length by 1, and recurse down
for i := range ex {
copy(ex[i:len(ex)], ex_in[i+1:len(ex_in)])
ex[i] = &node
for j := i + 1; j < len(ex_in); j++ {
node.left = ex_in[i]
node.right = ex_in[j]
// try all 4 operators
for o := op_add; o <= op_div; o++ {
node.op = o
if solve(ex) {
return true
}
}
// also - and / are not commutative, so swap arguments
node.left = ex_in[j]
node.right = ex_in[i]
node.op = op_sub
if solve(ex) {
return true
}
node.op = op_div
if solve(ex) {
return true
}
if j < len(ex) {
ex[j] = ex_in[j]
}
}
ex[i] = ex_in[i]
}
return false
}
func main() {
cards := make([]*Expr, n_cards)
rand.Seed(time.Now().Unix())
for k := 0; k < 10; k++ {
for i := 0; i < n_cards; i++ {
cards[i] = &Expr{op_num, nil, nil,
frac{rand.Intn(digit_range-1) + 1, 1}}
fmt.Printf(" %d", cards[i].value.num)
}
fmt.Print(": ")
if !solve(cards) {
fmt.Println("No solution")
}
}
} |
http://rosettacode.org/wiki/15_puzzle_game | 15 puzzle game |
Task
Implement the Fifteen Puzzle Game.
The 15-puzzle is also known as:
Fifteen Puzzle
Gem Puzzle
Boss Puzzle
Game of Fifteen
Mystic Square
14-15 Puzzle
and some others.
Related Tasks
15 Puzzle Solver
16 Puzzle Game
| #Action.21 | Action! | DEFINE BOARDSIZE="16"
DEFINE X0="13"
DEFINE Y0="6"
DEFINE ITEMW="3"
DEFINE ITEMH="2"
BYTE ARRAY board(BOARDSIZE)
BYTE emptyX,emptyY,solved,first=[1]
BYTE FUNC Index(BYTE x,y)
RETURN (x+y*4)
PROC UpdateItem(BYTE x,y)
BYTE item
Position(X0+x*ITEMW+1,Y0+y*ITEMH+1)
item=board(Index(x,y))
IF item=0 THEN
Print(" ")
ELSEIF item<10 THEN
Put(160) Put(item+176)
ELSE
Put(item/10+176)
Put(item MOD 10+176)
FI
RETURN
PROC UpdateBoard()
BYTE x,y
FOR y=0 TO 3
DO
FOR x=0 TO 3
DO
UpdateItem(x,y)
OD
OD
RETURN
PROC DrawGrid()
CHAR ARRAY
top=[13 17 18 18 23 18 18 23 18 18 23 18 18 5],
row=[13 124 32 32 124 32 32 124 32 32 124 32 32 124],
mid=[13 1 18 18 19 18 18 19 18 18 19 18 18 4],
bot=[13 26 18 18 24 18 18 24 18 18 24 18 18 3]
BYTE y,i
y=Y0
Position(X0,y) Print(top) y==+1
Position(X0,y) Print(row) y==+1
FOR i=0 TO 2
DO
Position(X0,y) Print(mid) y==+1
Position(X0,y) Print(row) y==+1
OD
Position(X0,y) Print(bot)
RETURN
PROC DrawBoard()
DrawGrid()
UpdateBoard()
RETURN
PROC FindEmpty()
BYTE i
FOR i=0 TO BOARDSIZE-1
DO
IF board(i)=0 THEN
emptyX=i MOD 4
emptyY=i/4
FI
OD
RETURN
PROC Wait(BYTE frames)
BYTE RTCLOK=$14
frames==+RTCLOK
WHILE frames#RTCLOK DO OD
RETURN
PROC UpdateStatus()
Position(9,3) Print("Game status: ")
IF solved THEN
Print("SOLVED !")
IF first=0 THEN
Sound(0,100,10,5) Wait(5)
Sound(0,60,10,5) Wait(5)
Sound(0,40,10,5) Wait(5)
Sound(0,0,0,0)
FI
first=0
ELSE
Print("Shuffled")
FI
RETURN
PROC InitBoard()
BYTE i
FOR i=1 TO BOARDSIZE
DO
board(i-1)=i MOD 16
OD
FindEmpty()
solved=1
UpdateStatus()
RETURN
BYTE FUNC IsSolved()
BYTE i
FOR i=1 TO BOARDSIZE
DO
IF board(i-1)#i MOD 16 THEN
RETURN (0)
FI
OD
RETURN (1)
PROC CheckStatus()
BYTE tmp
tmp=IsSolved()
IF solved#tmp THEN
solved=tmp
UpdateStatus()
FI
RETURN
PROC Swap(BYTE x1,y1,x2,y2)
BYTE tmp,i1,i2
i1=Index(x1,y1)
i2=Index(x2,y2)
tmp=board(i1)
board(i1)=board(i2)
board(i2)=tmp
UpdateItem(x1,y1)
UpdateItem(x2,y2)
CheckStatus()
RETURN
PROC Shuffle()
BYTE i,j,tmp
i=BOARDSIZE-1
WHILE i>0
DO
j=Rand(i)
tmp=board(i)
board(i)=board(j)
board(j)=tmp
i==-1
OD
FindEmpty()
UpdateBoard()
CheckStatus()
RETURN
PROC MoveLeft()
IF emptyX=0 THEN RETURN FI
Swap(emptyX,emptyY,emptyX-1,emptyY)
emptyX==-1
RETURN
PROC MoveRight()
IF emptyX=3 THEN RETURN FI
Swap(emptyX,emptyY,emptyX+1,emptyY)
emptyX==+1
RETURN
PROC MoveUp()
IF emptyY=0 THEN RETURN FI
Swap(emptyX,emptyY,emptyX,emptyY-1)
emptyY==-1
RETURN
PROC MoveDown()
IF emptyY=3 THEN RETURN FI
Swap(emptyX,emptyY,emptyX,emptyY+1)
emptyY==+1
RETURN
PROC Main()
BYTE k,lastStick=[255],currStick,
CH=$02FC, ;Internal hardware value for last key pressed
CRSINH=$02F0 ;Controls visibility of cursor
Graphics(0)
SetColor(2,0,2)
CRSINH=1 ;hide cursor
Position(10,18) Print("Joystick - move tiles")
Position(9,19) Print("Space bar - shuffle")
Position(15,20) Print("ESC - exit")
InitBoard()
DrawBoard()
DO
currStick=Stick(0)
IF currStick#lastStick THEN
IF currStick=11 THEN MoveRight()
ELSEIF currStick=7 THEN MoveLeft()
ELSEIF currStick=13 THEN MoveUp()
ELSEIF currStick=14 THEN MoveDown()
FI
FI
lastStick=currStick
k=CH
IF k#$FF THEN CH=$FF FI
IF k=33 THEN Shuffle()
ELSEIF k=28 THEN EXIT
FI
OD
RETURN |
http://rosettacode.org/wiki/2048 | 2048 | Task
Implement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.
Rules of the game
The rules are that on each turn the player must choose a direction (up, down, left or right).
All tiles move as far as possible in that direction, some move more than others.
Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.
A move is valid when at least one tile can be moved, if only by combination.
A new tile with the value of 2 is spawned at the end of each turn at a randomly chosen empty square (if there is one).
Adding a new tile on a blank space. Most of the time, a new 2 is to be added, and occasionally (10% of the time), a 4.
To win, the player must create a tile with the number 2048.
The player loses if no valid moves are possible.
The name comes from the popular open-source implementation of this game mechanic, 2048.
Requirements
"Non-greedy" movement.
The tiles that were created by combining other tiles should not be combined again during the same turn (move).
That is to say, that moving the tile row of:
[2][2][2][2]
to the right should result in:
......[4][4]
and not:
.........[8]
"Move direction priority".
If more than one variant of combining is possible, move direction shall indicate which combination will take effect.
For example, moving the tile row of:
...[2][2][2]
to the right should result in:
......[2][4]
and not:
......[4][2]
Check for valid moves. The player shouldn't be able to skip their turn by trying a move that doesn't change the board.
Check for a win condition.
Check for a lose condition.
| #BASIC | BASIC |
SCREEN 13
PALETTE 1, pColor(35, 33, 31)
PALETTE 2, pColor(46, 46, 51)
PALETTE 3, pColor(59, 56, 50)
PALETTE 4, pColor(61, 44, 30)
PALETTE 5, pColor(61, 37, 25)
PALETTE 6, pColor(62, 31, 24)
PALETTE 7, pColor(62, 24, 15)
PALETTE 8, pColor(59, 52, 29)
PALETTE 9, pColor(59, 51, 24)
PALETTE 10, pColor(59, 50, 20)
PALETTE 11, pColor(59, 49, 16)
PALETTE 12, pColor(59, 49, 12)
PALETTE 13, pColor(15, 15, 13)
PALETTE 14, pColor(23, 22, 20)
DIM SHARED gDebug
DIM SHARED gOriginX
DIM SHARED gOriginY
DIM SHARED gTextOriginX
DIM SHARED gTextOriginY
DIM SHARED gSquareSide
DIM SHARED gGridSize
gGridSize = 4 ' grid size (4 -> 4x4)
DIM SHARED gGrid(gGridSize, gGridSize)
DIM SHARED gScore
' Don't touch these numbers, seriously
gOriginX = 75 'pixel X of top left of grid
gOriginY = 12 'pixel Y of top right of grid
gTextOriginX = 11
gTextOriginY = 3
gSquareSide = 38 'width/height of block in pixels
'set up all the things!
gDebug = 0
RANDOMIZE TIMER
CLS
start:
initGrid
initGraphicGrid
renderGrid
updateScore
gScore = 0
LOCATE 23, 1
PRINT "Move with arrow keys. (R)estart, (Q)uit"
' keyboard input loop
DO
DO
k$ = INKEY$
LOOP UNTIL k$ <> ""
SELECT CASE k$
CASE CHR$(0) + CHR$(72) 'up
processMove ("u")
CASE CHR$(0) + CHR$(80) 'down
processMove ("d")
CASE CHR$(0) + CHR$(77) 'right
processMove ("r")
CASE CHR$(0) + CHR$(75) 'left
processMove ("l")
CASE CHR$(27) 'escape
GOTO programEnd
CASE "q"
GOTO programEnd
CASE "Q"
GOTO programEnd
CASE "r"
GOTO start
CASE "R"
GOTO start
END SELECT
LOOP
programEnd:
SUB addblock
DIM emptyCells(gGridSize * gGridSize, 2)
emptyCellCount = 0
FOR x = 0 TO gGridSize - 1
FOR y = 0 TO gGridSize - 1
IF gGrid(x, y) = 0 THEN
emptyCells(emptyCellCount, 0) = x
emptyCells(emptyCellCount, 1) = y
emptyCellCount = emptyCellCount + 1
END IF
NEXT y
NEXT x
IF emptyCellCount > 0 THEN
index = INT(RND * emptyCellCount)
num = CINT(RND + 1) * 2
gGrid(emptyCells(index, 0), emptyCells(index, 1)) = num
END IF
END SUB
SUB drawNumber (num, xPos, yPos)
SELECT CASE num
CASE 0: c = 16
CASE 2: c = 2
CASE 4: c = 3
CASE 8: c = 4
CASE 16: c = 5
CASE 32: c = 6
CASE 64: c = 7
CASE 128: c = 8
CASE 256: c = 9
CASE 512: c = 10
CASE 1024: c = 11
CASE 2048: c = 12
CASE 4096: c = 13
CASE 8192: c = 13
CASE ELSE: c = 13
END SELECT
x = xPos * (gSquareSide + 2) + gOriginX + 1
y = yPos * (gSquareSide + 2) + gOriginY + 1
LINE (x + 1, y + 1)-(x + gSquareSide - 1, y + gSquareSide - 1), c, BF
IF num > 0 THEN
LOCATE gTextOriginY + 1 + (yPos * 5), gTextOriginX + (xPos * 5)
PRINT " "
LOCATE gTextOriginY + 2 + (yPos * 5), gTextOriginX + (xPos * 5)
PRINT pad$(num)
LOCATE gTextOriginY + 3 + (yPos * 5), gTextOriginX + (xPos * 5)
'PRINT " "
END IF
END SUB
FUNCTION getAdjacentCell (x, y, d AS STRING)
IF (d = "l" AND x = 0) OR (d = "r" AND x = gGridSize - 1) OR (d = "u" AND y = 0) OR (d = "d" AND y = gGridSize - 1) THEN
getAdjacentCell = -1
ELSE
SELECT CASE d
CASE "l": getAdjacentCell = gGrid(x - 1, y)
CASE "r": getAdjacentCell = gGrid(x + 1, y)
CASE "u": getAdjacentCell = gGrid(x, y - 1)
CASE "d": getAdjacentCell = gGrid(x, y + 1)
END SELECT
END IF
END FUNCTION
'Draws the outside grid (doesn't render tiles)
SUB initGraphicGrid
gridSide = (gSquareSide + 2) * gGridSize
LINE (gOriginX, gOriginY)-(gOriginX + gridSide, gOriginY + gridSide), 14, BF 'outer square, 3 thick
LINE (gOriginX, gOriginY)-(gOriginX + gridSide, gOriginY + gridSide), 1, B 'outer square, 3 thick
LINE (gOriginX - 1, gOriginY - 1)-(gOriginX + gridSide + 1, gOriginY + gridSide + 1), 1, B
LINE (gOriginX - 2, gOriginY - 2)-(gOriginX + gridSide + 2, gOriginY + gridSide + 2), 1, B
FOR x = gOriginX + gSquareSide + 2 TO gOriginX + (gSquareSide + 2) * gGridSize STEP gSquareSide + 2 ' horizontal lines
LINE (x, gOriginY)-(x, gOriginY + gridSide), 1
NEXT x
FOR y = gOriginY + gSquareSide + 2 TO gOriginY + (gSquareSide + 2) * gGridSize STEP gSquareSide + 2 ' vertical lines
LINE (gOriginX, y)-(gOriginX + gridSide, y), 1
NEXT y
END SUB
'Init the (data) grid with 0s
SUB initGrid
FOR x = 0 TO 3
FOR y = 0 TO 3
gGrid(x, y) = 0
NEXT y
NEXT x
addblock
addblock
END SUB
SUB moveBlock (sourceX, sourceY, targetX, targetY, merge)
IF sourceX < 0 OR sourceX >= gGridSize OR sourceY < 0 OR sourceY >= gGridSize AND gDebug = 1 THEN
LOCATE 0, 0
PRINT "moveBlock: source coords out of bounds"
END IF
IF targetX < 0 OR targetX >= gGridSize OR targetY < 0 OR targetY >= gGridSize AND gDebug = 1 THEN
LOCATE 0, 0
PRINT "moveBlock: source coords out of bounds"
END IF
sourceSquareValue = gGrid(sourceX, sourceY)
targetSquareValue = gGrid(targetX, targetY)
IF merge = 1 THEN
IF sourceSquareValue = targetSquareValue THEN
gGrid(sourceX, sourceY) = 0
gGrid(targetX, targetY) = targetSquareValue * 2
gScore = gScore + targetSquareValue * 2 ' Points!
ELSEIF gDebug = 1 THEN
LOCATE 0, 0
PRINT "moveBlock: Attempted to merge unequal sqs"
END IF
ELSE
IF targetSquareValue = 0 THEN
gGrid(sourceX, sourceY) = 0
gGrid(targetX, targetY) = sourceSquareValue
ELSEIF gDebug = 1 THEN
LOCATE 0, 0
PRINT "moveBlock: Attempted to move to non-empty block"
END IF
END IF
END SUB
FUNCTION pad$ (num)
strNum$ = LTRIM$(STR$(num))
SELECT CASE LEN(strNum$)
CASE 1: pad = " " + strNum$ + " "
CASE 2: pad = " " + strNum$ + " "
CASE 3: pad = " " + strNum$
CASE 4: pad = strNum$
END SELECT
END FUNCTION
FUNCTION pColor (r, g, b)
pColor = (r + g * 256 + b * 65536)
END FUNCTION
SUB processMove (dir AS STRING)
' dir can be 'l', 'r', 'u', or 'd'
hasMoved = 0
IF dir = "l" THEN
FOR y = 0 TO gGridSize - 1
wasMerge = 0
FOR x = 0 TO gGridSize - 1
GOSUB processBlock
NEXT x
NEXT y
ELSEIF dir = "r" THEN
FOR y = 0 TO gGridSize - 1
wasMerge = 0
FOR x = gGridSize - 1 TO 0 STEP -1
GOSUB processBlock
NEXT x
NEXT y
ELSEIF dir = "u" THEN
FOR x = 0 TO gGridSize - 1
wasMerge = 0
FOR y = 0 TO gGridSize - 1
GOSUB processBlock
NEXT y
NEXT x
ELSEIF dir = "d" THEN
FOR x = 0 TO gGridSize - 1
wasMerge = 0
FOR y = gGridSize - 1 TO 0 STEP -1
GOSUB processBlock
NEXT y
NEXT x
END IF
GOTO processMoveEnd
moveToObstacle:
curX = x
curY = y
DO WHILE getAdjacentCell(curX, curY, dir) = 0
SELECT CASE dir
CASE "l": curX = curX - 1
CASE "r": curX = curX + 1
CASE "u": curY = curY - 1
CASE "d": curY = curY + 1
END SELECT
LOOP
RETURN
processBlock:
merge = 0
IF gGrid(x, y) <> 0 THEN ' have block
GOSUB moveToObstacle ' figure out where it can be moved to
IF getAdjacentCell(curX, curY, dir) = gGrid(x, y) AND wasMerge = 0 THEN ' obstacle can be merged with
merge = 1
wasMerge = 1
ELSE
wasMerge = 0
END IF
IF curX <> x OR curY <> y OR merge = 1 THEN
mergeDirX = 0
mergeDirY = 0
IF merge = 1 THEN
SELECT CASE dir
CASE "l": mergeDirX = -1
CASE "r": mergeDirX = 1
CASE "u": mergeDirY = -1
CASE "d": mergeDirY = 1
END SELECT
END IF
CALL moveBlock(x, y, curX + mergeDirX, curY + mergeDirY, merge) ' move to before obstacle or merge
hasMoved = 1
END IF
END IF
RETURN
processMoveEnd:
IF hasMoved = 1 THEN addblock
renderGrid
updateScore
END SUB
SUB renderGrid
FOR x = 0 TO gGridSize - 1
FOR y = 0 TO gGridSize - 1
CALL drawNumber(gGrid(x, y), x, y)
NEXT y
NEXT x
END SUB
SUB updateScore
LOCATE 1, 10
PRINT "Score:" + STR$(gScore)
END SUB
|
http://rosettacode.org/wiki/4-rings_or_4-squares_puzzle | 4-rings or 4-squares puzzle | 4-rings or 4-squares puzzle
You are encouraged to solve this task according to the task description, using any language you may know.
Task
Replace a, b, c, d, e, f, and
g with the decimal
digits LOW ───► HIGH
such that the sum of the letters inside of each of the four large squares add up to
the same sum.
╔══════════════╗ ╔══════════════╗
║ ║ ║ ║
║ a ║ ║ e ║
║ ║ ║ ║
║ ┌───╫──────╫───┐ ┌───╫─────────┐
║ │ ║ ║ │ │ ║ │
║ │ b ║ ║ d │ │ f ║ │
║ │ ║ ║ │ │ ║ │
║ │ ║ ║ │ │ ║ │
╚══════════╪═══╝ ╚═══╪══════╪═══╝ │
│ c │ │ g │
│ │ │ │
│ │ │ │
└──────────────┘ └─────────────┘
Show all output here.
Show all solutions for each letter being unique with
LOW=1 HIGH=7
Show all solutions for each letter being unique with
LOW=3 HIGH=9
Show only the number of solutions when each letter can be non-unique
LOW=0 HIGH=9
Related task
Solve the no connection puzzle
| #Racket | Racket | #lang racket
(define solution? (match-lambda [(list a b c d e f g) (= (+ a b) (+ b c d) (+ d e f) (+ f g))]))
(define (fold-4-rings-or-4-squares-puzzle lo hi kons k0)
(for*/fold ((k k0))
((combination (in-combinations (range lo (add1 hi)) 7))
(permutation (in-permutations combination))
#:when (solution? permutation))
(kons permutation k)))
(fold-4-rings-or-4-squares-puzzle 1 7 cons null)
(fold-4-rings-or-4-squares-puzzle 3 9 cons null)
(fold-4-rings-or-4-squares-puzzle 0 9 (λ (ignored-solution count) (add1 count)) 0) |
http://rosettacode.org/wiki/15_puzzle_solver | 15 puzzle solver | Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.
For this task you will be using the following puzzle:
15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
The output must show the moves' directions, like so: left, left, left, down, right... and so on.
There are two solutions, of fifty-two moves:
rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd
rrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd
see: Pretty Print of Optimal Solution
Finding either one, or both is an acceptable result.
Extra credit.
Solve the following problem:
0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1
Related Task
15 puzzle game
A* search algorithm
| #Fortran | Fortran | 59: H = MOD(ABS(PRODUCT(BRD)),APRIME)
004016E3 mov esi,1
004016E8 mov ecx,1
004016ED cmp ecx,2
004016F0 jg MAIN$SLIDESOLVE+490h (0040171e)
004016F2 cmp ecx,1
004016F5 jl MAIN$SLIDESOLVE+46Eh (004016fc)
004016F7 cmp ecx,2
004016FA jle MAIN$SLIDESOLVE+477h (00401705)
004016FC xor eax,eax
004016FE mov dword ptr [ebp-54h],eax
00401701 dec eax
00401702 bound eax,qword ptr [ebp-54h]
00401705 imul edx,ecx,4
00401708 mov edx,dword ptr H (00473714)[edx]
0040170E imul edx,esi
00401711 mov esi,edx
00401713 mov eax,ecx
00401715 add eax,1
0040171A mov ecx,eax
0040171C jmp MAIN$SLIDESOLVE+45Fh (004016ed)
0040171E mov eax,esi
00401720 cmp eax,0
00401725 jge MAIN$SLIDESOLVE+49Bh (00401729)
00401727 neg eax
00401729 mov edx,10549h
0040172E mov dword ptr [ebp-54h],edx
00401731 cdq
00401732 idiv eax,dword ptr [ebp-54h]
00401735 mov eax,edx
00401737 mov dword ptr [H (00473714)],eax
60: write (6,*) H,bored
|
http://rosettacode.org/wiki/99_bottles_of_beer | 99 bottles of beer | Task
Display the complete lyrics for the song: 99 Bottles of Beer on the Wall.
The beer song
The lyrics follow this form:
99 bottles of beer on the wall
99 bottles of beer
Take one down, pass it around
98 bottles of beer on the wall
98 bottles of beer on the wall
98 bottles of beer
Take one down, pass it around
97 bottles of beer on the wall
... and so on, until reaching 0 (zero).
Grammatical support for 1 bottle of beer is optional.
As with any puzzle, try to do it in as creative/concise/comical a way
as possible (simple, obvious solutions allowed, too).
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
See also
http://99-bottles-of-beer.net/
Category:99_Bottles_of_Beer
Category:Programming language families
Wikipedia 99 bottles of beer
| #APL | APL | bob ← { (⍕⍵), ' bottle', (1=⍵)↓'s of beer'}
bobw ← {(bob ⍵) , ' on the wall'}
beer ← { (bobw ⍵) , ', ', (bob ⍵) , '; take one down and pass it around, ', bobw ⍵-1}
|
http://rosettacode.org/wiki/24_game | 24 game | The 24 Game tests one's mental arithmetic.
Task
Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
The goal is for the player to enter an expression that (numerically) evaluates to 24.
Only the following operators/functions are allowed: multiplication, division, addition, subtraction
Division should use floating point or rational arithmetic, etc, to preserve remainders.
Brackets are allowed, if using an infix expression evaluator.
Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
The order of the digits when given does not have to be preserved.
Notes
The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
The task is not for the program to generate the expression, or test whether an expression is even possible.
Related tasks
24 game/Solve
Reference
The 24 Game on h2g2.
| #Elixir | Elixir | defmodule Game24 do
def main do
IO.puts "24 Game"
play
end
defp play do
IO.puts "Generating 4 digits..."
digts = for _ <- 1..4, do: Enum.random(1..9)
IO.puts "Your digits\t#{inspect digts, char_lists: :as_lists}"
read_eval(digts)
play
end
defp read_eval(digits) do
exp = IO.gets("Your expression: ") |> String.strip
if exp in ["","q"], do: exit(:normal) # give up
case {correct_nums(exp, digits), eval(exp)} do
{:ok, x} when x==24 -> IO.puts "You Win!"
{:ok, x} -> IO.puts "You Lose with #{inspect x}!"
{err, _} -> IO.puts "The following numbers are wrong: #{inspect err, char_lists: :as_lists}"
end
end
defp correct_nums(exp, digits) do
nums = String.replace(exp, ~r/\D/, " ") |> String.split |> Enum.map(&String.to_integer &1)
if length(nums)==4 and (nums--digits)==[], do: :ok, else: nums
end
defp eval(exp) do
try do
Code.eval_string(exp) |> elem(0)
rescue
e -> Exception.message(e)
end
end
end
Game24.main |
http://rosettacode.org/wiki/A%2BB | A+B | A+B ─── a classic problem in programming contests, it's given so contestants can gain familiarity with the online judging system being used.
Task
Given two integers, A and B.
Their sum needs to be calculated.
Input data
Two integers are written in the input stream, separated by space(s):
(
−
1000
≤
A
,
B
≤
+
1000
)
{\displaystyle (-1000\leq A,B\leq +1000)}
Output data
The required output is one integer: the sum of A and B.
Example
input
output
2 2
4
3 2
5
| #COBOL | COBOL | IDENTIFICATION DIVISION.
PROGRAM-ID. A-Plus-B.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 A PIC S9(5).
01 B PIC S9(5).
01 A-B-Sum PIC S9(5).
PROCEDURE DIVISION.
ACCEPT A
ACCEPT B
ADD A TO B GIVING A-B-Sum
DISPLAY A-B-Sum
GOBACK
. |
http://rosettacode.org/wiki/Ackermann_function | Ackermann function | The Ackermann function is a classic example of a recursive function, notable especially because it is not a primitive recursive function. It grows very quickly in value, as does the size of its call tree.
The Ackermann function is usually defined as follows:
A
(
m
,
n
)
=
{
n
+
1
if
m
=
0
A
(
m
−
1
,
1
)
if
m
>
0
and
n
=
0
A
(
m
−
1
,
A
(
m
,
n
−
1
)
)
if
m
>
0
and
n
>
0.
{\displaystyle A(m,n)={\begin{cases}n+1&{\mbox{if }}m=0\\A(m-1,1)&{\mbox{if }}m>0{\mbox{ and }}n=0\\A(m-1,A(m,n-1))&{\mbox{if }}m>0{\mbox{ and }}n>0.\end{cases}}}
Its arguments are never negative and it always terminates.
Task
Write a function which returns the value of
A
(
m
,
n
)
{\displaystyle A(m,n)}
. Arbitrary precision is preferred (since the function grows so quickly), but not required.
See also
Conway chained arrow notation for the Ackermann function.
| #Ursala | Ursala | #import std
#import nat
ackermann =
~&al^?\successor@ar ~&ar?(
^R/~&f ^/predecessor@al ^|R/~& ^|/~& predecessor,
^|R/~& ~&\1+ predecessor@l) |
http://rosettacode.org/wiki/ABC_problem | ABC problem | ABC problem
You are encouraged to solve this task according to the task description, using any language you may know.
You are given a collection of ABC blocks (maybe like the ones you had when you were a kid).
There are twenty blocks with two letters on each block.
A complete alphabet is guaranteed amongst all sides of the blocks.
The sample collection of blocks:
(B O)
(X K)
(D Q)
(C P)
(N A)
(G T)
(R E)
(T G)
(Q D)
(F S)
(J W)
(H U)
(V I)
(A N)
(O B)
(E R)
(F S)
(L Y)
(P C)
(Z M)
Task
Write a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.
The rules are simple:
Once a letter on a block is used that block cannot be used again
The function should be case-insensitive
Show the output on this page for the following 7 words in the following example
Example
>>> can_make_word("A")
True
>>> can_make_word("BARK")
True
>>> can_make_word("BOOK")
False
>>> can_make_word("TREAT")
True
>>> can_make_word("COMMON")
False
>>> can_make_word("SQUAD")
True
>>> can_make_word("CONFUSE")
True
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
| #Fortran | Fortran | !-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Thu Jun 5 01:52:03
!
!make f && for a in '' a bark book treat common squad confuse ; do echo $a | ./f ; done
!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none -g f.f08 -o f
! T
! T A NA
! T BARK BO NA RE XK
! F BOOK OB BO -- --
! T TREAT GT RE ER NA TG
! F COMMON PC OB ZM -- -- --
! T SQUAD FS DQ HU NA QD
! T CONFUSE CP BO NA FS HU FS RE
!
!Compilation finished at Thu Jun 5 01:52:03
program abc
implicit none
integer, parameter :: nblocks = 20
character(len=nblocks) :: goal
integer, dimension(nblocks) :: solution
character(len=2), dimension(0:nblocks) :: blocks_copy, blocks = &
&(/'--','BO','XK','DQ','CP','NA','GT','RE','TG','QD','FS','JW','HU','VI','AN','OB','ER','FS','LY','PC','ZM'/)
logical :: valid
integer :: i, iostat
read(5,*,iostat=iostat) goal
if (iostat .ne. 0) goal = ''
call ucase(goal)
solution = 0
blocks_copy = blocks
valid = assign_block(goal(1:len_trim(goal)), blocks, solution, 1)
write(6,*) valid, ' '//goal, (' '//blocks_copy(solution(i)), i=1,len_trim(goal))
contains
recursive function assign_block(goal, blocks, solution, n) result(valid)
implicit none
logical :: valid
character(len=*), intent(in) :: goal
character(len=2), dimension(0:), intent(inout) :: blocks
integer, dimension(:), intent(out) :: solution
integer, intent(in) :: n
integer :: i
character(len=2) :: backing_store
valid = .true.
if (len(goal)+1 .eq. n) return
do i=1, size(blocks)
if (index(blocks(i),goal(n:n)) .ne. 0) then
backing_store = blocks(i)
blocks(i) = ''
solution(n) = i
if (assign_block(goal, blocks, solution, n+1)) return
blocks(i) = backing_store
end if
end do
valid = .false.
return
end function assign_block
subroutine ucase(a)
implicit none
character(len=*), intent(inout) :: a
integer :: i, j
do i = 1, len_trim(a)
j = index('abcdefghijklmnopqrstuvwxyz',a(i:i))
if (j .ne. 0) a(i:i) = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'(j:j)
end do
end subroutine ucase
end program abc |
http://rosettacode.org/wiki/100_prisoners | 100 prisoners |
The Problem
100 prisoners are individually numbered 1 to 100
A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.
Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.
Prisoners start outside the room
They can decide some strategy before any enter the room.
Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.
A prisoner can open no more than 50 drawers.
A prisoner tries to find his own number.
A prisoner finding his own number is then held apart from the others.
If all 100 prisoners find their own numbers then they will all be pardoned. If any don't then all sentences stand.
The task
Simulate several thousand instances of the game where the prisoners randomly open drawers
Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:
First opening the drawer whose outside number is his prisoner number.
If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).
Show and compare the computed probabilities of success for the two strategies, here, on this page.
References
The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).
wp:100 prisoners problem
100 Prisoners Escape Puzzle DataGenetics.
Random permutation statistics#One hundred prisoners on Wikipedia.
| #Delphi | Delphi | for i range 100
drawer[] &= i
sampler[] &= i
.
subr shuffle_drawer
for i = len drawer[] downto 2
r = random i
swap drawer[r] drawer[i - 1]
.
.
subr play_random
call shuffle_drawer
found = 1
prisoner = 0
while prisoner < 100 and found = 1
found = 0
i = 0
while i < 50 and found = 0
r = random (100 - i)
card = drawer[sampler[r]]
swap sampler[r] sampler[100 - i - 1]
if card = prisoner
found = 1
.
i += 1
.
prisoner += 1
.
.
subr play_optimal
call shuffle_drawer
found = 1
prisoner = 0
while prisoner < 100 and found = 1
reveal = prisoner
found = 0
i = 0
while i < 50 and found = 0
card = drawer[reveal]
if card = prisoner
found = 1
.
reveal = card
i += 1
.
prisoner += 1
.
.
n = 10000
pardoned = 0
for round range n
call play_random
pardoned += found
.
print "random: " & 100.0 * pardoned / n & "%"
#
pardoned = 0
for round range n
call play_optimal
pardoned += found
.
print "optimal: " & 100.0 * pardoned / n & "%" |
http://rosettacode.org/wiki/Abundant_odd_numbers | Abundant odd numbers | An Abundant number is a number n for which the sum of divisors σ(n) > 2n,
or, equivalently, the sum of proper divisors (or aliquot sum) s(n) > n.
E.G.
12 is abundant, it has the proper divisors 1,2,3,4 & 6 which sum to 16 ( > 12 or n);
or alternately, has the sigma sum of 1,2,3,4,6 & 12 which sum to 28 ( > 24 or 2n).
Abundant numbers are common, though even abundant numbers seem to be much more common than odd abundant numbers.
To make things more interesting, this task is specifically about finding odd abundant numbers.
Task
Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.
Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.
Find and display here: the first abundant odd number greater than one billion (109) and either its proper divisor sum or sigma sum.
References
OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)
American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)
| #Wren | Wren | import "/fmt" for Fmt
import "/math" for Int, Nums
var sumStr = Fn.new { |divs| divs.reduce("") { |acc, div| acc + "%(div) + " }[0...-3] }
var abundantOdd = Fn.new { |searchFrom, countFrom, countTo, printOne|
var count = countFrom
var n = searchFrom
while (count < countTo) {
var divs = Int.properDivisors(n)
var tot = Nums.sum(divs)
if (tot > n) {
count = count + 1
if (!printOne || count >= countTo) {
var s = sumStr.call(divs)
if (!printOne) {
System.print("%(Fmt.d(2, count)). %(Fmt.d(5, n)) < %(s) = %(tot)")
} else {
System.print("%(n) < %(s) = %(tot)")
}
}
}
n = n + 2
}
return n
}
var MAX = 25
System.print("The first %(MAX) abundant odd numbers are:")
var n = abundantOdd.call(1, 0, 25, false)
System.print("\nThe one thousandth abundant odd number is:")
abundantOdd.call(n, 25, 1000, true)
System.print("\nThe first abundant odd number above one billion is:")
abundantOdd.call(1e9+1, 0, 1, true) |
http://rosettacode.org/wiki/21_game | 21 game | 21 game
You are encouraged to solve this task according to the task description, using any language you may know.
21 is a two player game, the game is played by choosing
a number (1, 2, or 3) to be added to the running total.
The game is won by the player whose chosen number causes the running total
to reach exactly 21.
The running total starts at zero.
One player will be the computer.
Players alternate supplying a number to be added to the running total.
Task
Write a computer program that will:
do the prompting (or provide a button menu),
check for errors and display appropriate error messages,
do the additions (add a chosen number to the running total),
display the running total,
provide a mechanism for the player to quit/exit/halt/stop/close the program,
issue a notification when there is a winner, and
determine who goes first (maybe a random or user choice, or can be specified when the game begins).
| #R | R | game21<-function(first = c("player","ai","random"),sleep=.5){
state = 0
finished = F
turn = 1
if(length(first)==1 && startsWith(tolower(first),"r")){
first = rbinom(1,1,.5)
}else{
first = (length(first)>1 || startsWith(tolower(first),"p"))
}
while(!finished){
if(turn>1 || first){
cat("The total is now",state,"\n");Sys.sleep(sleep)
while(T){
player.move = readline(prompt = "Enter move: ")
if((player.move=="1"||player.move=="2"||player.move=="3") && state+as.numeric(player.move)<=21){
player.move = as.numeric(player.move)
state = state + player.move
break
}else if(tolower(player.move)=="exit"|tolower(player.move)=="quit"|tolower(player.move)=="end"){
cat("Goodbye.\n")
finished = T
break
}else{
cat("Error: invaid entry.\n")
}
}
}
if(state == 21){
cat("You win!\n")
finished = T
}
if(!finished){
cat("The total is now",state,"\n");Sys.sleep(sleep)
while(T){
ai.move = sample(1:3,1)
if(state+ai.move<=21){
break
}
}
state = state + ai.move
cat("The AI chooses",ai.move,"\n");Sys.sleep(sleep)
if(state == 21){
cat("The AI wins!\n")
finished = T
}
}
turn = turn + 1
}
} |
http://rosettacode.org/wiki/24_game/Solve | 24 game/Solve | task
Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the 24 game.
Show examples of solutions generated by the program.
Related task
Arithmetic Evaluator
| #Gosu | Gosu |
uses java.lang.Integer
uses java.lang.Double
uses java.lang.System
uses java.util.ArrayList
uses java.util.LinkedList
uses java.util.List
uses java.util.Scanner
uses java.util.Stack
function permutations<T>( lst : List<T> ) : List<List<T>> {
if( lst.size() == 0 ) return {}
if( lst.size() == 1 ) return { lst }
var pivot = lst.get(lst.size()-1)
var sublist = new ArrayList<T>( lst )
sublist.remove( sublist.size() - 1 )
var subPerms = permutations( sublist )
var ret = new ArrayList<List<T>>()
for( x in subPerms ) {
for( e in x index i ) {
var next = new LinkedList<T>( x )
next.add( i, pivot )
ret.add( next )
}
x.add( pivot )
ret.add( x )
}
return ret
}
function readVals() : List<Integer> {
var line = new java.io.BufferedReader( new java.io.InputStreamReader( System.in ) ).readLine()
var scan = new Scanner( line )
var ret = new ArrayList<Integer>()
for( i in 0..3 ) {
var next = scan.nextInt()
if( 0 >= next || next >= 10 ) {
print( "Invalid entry: ${next}" )
return null
}
ret.add( next )
}
return ret
}
function getOp( i : int ) : char[] {
var ret = new char[3]
var ops = { '+', '-', '*', '/' }
ret[0] = ops[i / 16]
ret[1] = ops[(i / 4) % 4 ]
ret[2] = ops[i % 4 ]
return ret
}
function isSoln( nums : List<Integer>, ops : char[] ) : boolean {
var stk = new Stack<Double>()
for( n in nums ) {
stk.push( n )
}
for( c in ops ) {
var r = stk.pop().doubleValue()
var l = stk.pop().doubleValue()
if( c == '+' ) {
stk.push( l + r )
} else if( c == '-' ) {
stk.push( l - r )
} else if( c == '*' ) {
stk.push( l * r )
} else if( c == '/' ) {
// Avoid division by 0
if( r == 0.0 ) {
return false
}
stk.push( l / r )
}
}
return java.lang.Math.abs( stk.pop().doubleValue() - 24.0 ) < 0.001
}
function printSoln( nums : List<Integer>, ops : char[] ) {
// RPN: a b c d + - *
// Infix (a * (b - (c + d)))
print( "Found soln: (${nums.get(0)} ${ops[0]} (${nums.get(1)} ${ops[1]} (${nums.get(2)} ${ops[2]} ${nums.get(3)})))" )
}
System.out.print( "#> " )
var vals = readVals()
var opPerms = 0..63
var solnFound = false
for( i in permutations( vals ) ) {
for( j in opPerms ) {
var opList = getOp( j )
if( isSoln( i, opList ) ) {
printSoln( i, opList )
solnFound = true
}
}
}
if( ! solnFound ) {
print( "No solution!" )
}
|
http://rosettacode.org/wiki/15_puzzle_game | 15 puzzle game |
Task
Implement the Fifteen Puzzle Game.
The 15-puzzle is also known as:
Fifteen Puzzle
Gem Puzzle
Boss Puzzle
Game of Fifteen
Mystic Square
14-15 Puzzle
and some others.
Related Tasks
15 Puzzle Solver
16 Puzzle Game
| #Ada | Ada | generic
Rows, Cols: Positive;
with function Name(N: Natural) return String; -- with Pre => (N < Rows*Cols);
-- Name(0) shall return the name for the empty tile
package Generic_Puzzle is
subtype Row_Type is Positive range 1 .. Rows;
subtype Col_Type is Positive range 1 .. Cols;
type Moves is (Up, Down, Left, Right);
type Move_Arr is array(Moves) of Boolean;
function Get_Point(Row: Row_Type; Col: Col_Type) return String;
function Possible return Move_Arr;
procedure Move(The_Move: Moves);
end Generic_Puzzle; |
http://rosettacode.org/wiki/2048 | 2048 | Task
Implement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.
Rules of the game
The rules are that on each turn the player must choose a direction (up, down, left or right).
All tiles move as far as possible in that direction, some move more than others.
Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.
A move is valid when at least one tile can be moved, if only by combination.
A new tile with the value of 2 is spawned at the end of each turn at a randomly chosen empty square (if there is one).
Adding a new tile on a blank space. Most of the time, a new 2 is to be added, and occasionally (10% of the time), a 4.
To win, the player must create a tile with the number 2048.
The player loses if no valid moves are possible.
The name comes from the popular open-source implementation of this game mechanic, 2048.
Requirements
"Non-greedy" movement.
The tiles that were created by combining other tiles should not be combined again during the same turn (move).
That is to say, that moving the tile row of:
[2][2][2][2]
to the right should result in:
......[4][4]
and not:
.........[8]
"Move direction priority".
If more than one variant of combining is possible, move direction shall indicate which combination will take effect.
For example, moving the tile row of:
...[2][2][2]
to the right should result in:
......[2][4]
and not:
......[4][2]
Check for valid moves. The player shouldn't be able to skip their turn by trying a move that doesn't change the board.
Check for a win condition.
Check for a lose condition.
| #BBC_BASIC | BBC BASIC | SIZE = 4 : MAX = SIZE-1
Won% = FALSE : Lost% = FALSE
@% = 5
DIM Board(MAX,MAX),Stuck% 3
PROCBreed
PROCPrint
REPEAT
Direction = GET-135
IF Direction > 0 AND Direction < 5 THEN
Moved% = FALSE
PROCShift
PROCMerge
PROCShift
IF Moved% THEN PROCBreed : !Stuck%=0 ELSE ?(Stuck%+Direction-1)=-1 : Lost% = !Stuck%=-1
PROCPrint
ENDIF
UNTIL Won% OR Lost%
IF Won% THEN PRINT "You WON! :-)" ELSE PRINT "You lost :-("
END
REM -----------------------------------------------------------------------------------------------------------------------
DEF PROCPrint
FOR i = 0 TO SIZE*SIZE-1
IF Board(i DIV SIZE,i MOD SIZE) THEN PRINT Board(i DIV SIZE,i MOD SIZE); ELSE PRINT " _";
IF i MOD SIZE = MAX THEN PRINT
NEXT
PRINT STRING$(SIZE,"-----")
ENDPROC
REM ----------------------------------------------------------------------------------------------------------------------
DEF PROCShift
IF Direction = 2 OR Direction = 3 THEN loopend = MAX : step = -1 ELSE loopend = 0 : step = 1
FOR row = loopend TO MAX-loopend STEP step
zeros = 0
FOR col = loopend TO MAX-loopend STEP step
IF Direction < 3 THEN
IF Board(row,col) = 0 THEN zeros += step ELSE IF zeros THEN SWAP Board(row,col),Board(row,col-zeros) : Moved% = TRUE
ELSE
IF Board(col,row) = 0 THEN zeros += step ELSE IF zeros THEN SWAP Board(col,row),Board(col-zeros,row) : Moved% = TRUE
ENDIF
NEXT
NEXT
ENDPROC
REM -----------------------------------------------------------------------------------------------------------------------
DEF PROCMerge
IF Direction = 1 THEN loopend = 0 : rowoff = 0 : coloff = 1 : step = 1
IF Direction = 2 THEN loopend = MAX : rowoff = 0 : coloff = -1 : step = -1
IF Direction = 3 THEN loopend = MAX : rowoff = -1 : coloff = 0 : step = -1
IF Direction = 4 THEN loopend = 0 : rowoff = 1 : coloff = 0 : step = 1
FOR row = loopend TO MAX-loopend-rowoff STEP step
FOR col = loopend TO MAX-loopend-coloff STEP step
IF Board(row,col) THEN IF Board(row,col) = Board(row+rowoff,col+coloff) THEN
Board(row,col) *= 2 : Board(row+rowoff,col+coloff) = 0
Moved% = TRUE
IF NOT Won% THEN Won% = Board(row,col)=2048
ENDIF
NEXT
NEXT
ENDPROC
REM -----------------------------------------------------------------------------------------------------------------------
DEF PROCBreed
cell = RND(SIZE*SIZE)-1
FOR i = 0 TO SIZE*SIZE-1
z = (cell+i) MOD (SIZE*SIZE)
IF Board(z DIV SIZE,z MOD SIZE) = 0 THEN Board(z DIV SIZE,z MOD SIZE) = 2-(RND(10)=1)*2 : EXIT FOR
NEXT
ENDPROC |
http://rosettacode.org/wiki/4-rings_or_4-squares_puzzle | 4-rings or 4-squares puzzle | 4-rings or 4-squares puzzle
You are encouraged to solve this task according to the task description, using any language you may know.
Task
Replace a, b, c, d, e, f, and
g with the decimal
digits LOW ───► HIGH
such that the sum of the letters inside of each of the four large squares add up to
the same sum.
╔══════════════╗ ╔══════════════╗
║ ║ ║ ║
║ a ║ ║ e ║
║ ║ ║ ║
║ ┌───╫──────╫───┐ ┌───╫─────────┐
║ │ ║ ║ │ │ ║ │
║ │ b ║ ║ d │ │ f ║ │
║ │ ║ ║ │ │ ║ │
║ │ ║ ║ │ │ ║ │
╚══════════╪═══╝ ╚═══╪══════╪═══╝ │
│ c │ │ g │
│ │ │ │
│ │ │ │
└──────────────┘ └─────────────┘
Show all output here.
Show all solutions for each letter being unique with
LOW=1 HIGH=7
Show all solutions for each letter being unique with
LOW=3 HIGH=9
Show only the number of solutions when each letter can be non-unique
LOW=0 HIGH=9
Related task
Solve the no connection puzzle
| #Raku | Raku | sub four-squares ( @list, :$unique=1, :$show=1 ) {
my @solutions;
for $unique.&combos -> @c {
@solutions.push: @c if [==]
@c[0] + @c[1],
@c[1] + @c[2] + @c[3],
@c[3] + @c[4] + @c[5],
@c[5] + @c[6];
}
say +@solutions, ($unique ?? ' ' !! ' non-'), "unique solutions found using {join(', ', @list)}.\n";
my $f = "%{@list.max.chars}s";
say join "\n", (('a'..'g').fmt: $f), @solutions».fmt($f), "\n" if $show;
multi combos ( $ where so * ) { @list.combinations(7).map: |*.permutations }
multi combos ( $ where not * ) { [X] @list xx 7 }
}
# TASK
four-squares( [1..7] );
four-squares( [3..9] );
four-squares( [8, 9, 11, 12, 17, 18, 20, 21] );
four-squares( [0..9], :unique(0), :show(0) ); |
http://rosettacode.org/wiki/15_puzzle_solver | 15 puzzle solver | Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.
For this task you will be using the following puzzle:
15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
The output must show the moves' directions, like so: left, left, left, down, right... and so on.
There are two solutions, of fifty-two moves:
rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd
rrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd
see: Pretty Print of Optimal Solution
Finding either one, or both is an acceptable result.
Extra credit.
Solve the following problem:
0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1
Related Task
15 puzzle game
A* search algorithm
| #Go | Go | package main
import "fmt"
var (
Nr = [16]int{3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3}
Nc = [16]int{3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2}
)
var (
n, _n int
N0, N3, N4 [85]int
N2 [85]uint64
)
const (
i = 1
g = 8
e = 2
l = 4
)
func fY() bool {
if N2[n] == 0x123456789abcdef0 {
return true
}
if N4[n] <= _n {
return fN()
}
return false
}
func fZ(w int) bool {
if w&i > 0 {
fI()
if fY() {
return true
}
n--
}
if w&g > 0 {
fG()
if fY() {
return true
}
n--
}
if w&e > 0 {
fE()
if fY() {
return true
}
n--
}
if w&l > 0 {
fL()
if fY() {
return true
}
n--
}
return false
}
func fN() bool {
switch N0[n] {
case 0:
switch N3[n] {
case 'l':
return fZ(i)
case 'u':
return fZ(e)
default:
return fZ(i + e)
}
case 3:
switch N3[n] {
case 'r':
return fZ(i)
case 'u':
return fZ(l)
default:
return fZ(i + l)
}
case 1, 2:
switch N3[n] {
case 'l':
return fZ(i + l)
case 'r':
return fZ(i + e)
case 'u':
return fZ(e + l)
default:
return fZ(l + e + i)
}
case 12:
switch N3[n] {
case 'l':
return fZ(g)
case 'd':
return fZ(e)
default:
return fZ(e + g)
}
case 15:
switch N3[n] {
case 'r':
return fZ(g)
case 'd':
return fZ(l)
default:
return fZ(g + l)
}
case 13, 14:
switch N3[n] {
case 'l':
return fZ(g + l)
case 'r':
return fZ(e + g)
case 'd':
return fZ(e + l)
default:
return fZ(g + e + l)
}
case 4, 8:
switch N3[n] {
case 'l':
return fZ(i + g)
case 'u':
return fZ(g + e)
case 'd':
return fZ(i + e)
default:
return fZ(i + g + e)
}
case 7, 11:
switch N3[n] {
case 'd':
return fZ(i + l)
case 'u':
return fZ(g + l)
case 'r':
return fZ(i + g)
default:
return fZ(i + g + l)
}
default:
switch N3[n] {
case 'd':
return fZ(i + e + l)
case 'l':
return fZ(i + g + l)
case 'r':
return fZ(i + g + e)
case 'u':
return fZ(g + e + l)
default:
return fZ(i + g + e + l)
}
}
}
func fI() {
g := (11 - N0[n]) * 4
a := N2[n] & uint64(15<<uint(g))
N0[n+1] = N0[n] + 4
N2[n+1] = N2[n] - a + (a << 16)
N3[n+1] = 'd'
N4[n+1] = N4[n]
cond := Nr[a>>uint(g)] <= N0[n]/4
if !cond {
N4[n+1]++
}
n++
}
func fG() {
g := (19 - N0[n]) * 4
a := N2[n] & uint64(15<<uint(g))
N0[n+1] = N0[n] - 4
N2[n+1] = N2[n] - a + (a >> 16)
N3[n+1] = 'u'
N4[n+1] = N4[n]
cond := Nr[a>>uint(g)] >= N0[n]/4
if !cond {
N4[n+1]++
}
n++
}
func fE() {
g := (14 - N0[n]) * 4
a := N2[n] & uint64(15<<uint(g))
N0[n+1] = N0[n] + 1
N2[n+1] = N2[n] - a + (a << 4)
N3[n+1] = 'r'
N4[n+1] = N4[n]
cond := Nc[a>>uint(g)] <= N0[n]%4
if !cond {
N4[n+1]++
}
n++
}
func fL() {
g := (16 - N0[n]) * 4
a := N2[n] & uint64(15<<uint(g))
N0[n+1] = N0[n] - 1
N2[n+1] = N2[n] - a + (a >> 4)
N3[n+1] = 'l'
N4[n+1] = N4[n]
cond := Nc[a>>uint(g)] >= N0[n]%4
if !cond {
N4[n+1]++
}
n++
}
func fifteenSolver(n int, g uint64) {
N0[0] = n
N2[0] = g
N4[0] = 0
}
func solve() {
if fN() {
fmt.Print("Solution found in ", n, " moves: ")
for g := 1; g <= n; g++ {
fmt.Printf("%c", N3[g])
}
fmt.Println()
} else {
n = 0
_n++
solve()
}
}
func main() {
fifteenSolver(8, 0xfe169b4c0a73d852)
solve()
} |
http://rosettacode.org/wiki/99_bottles_of_beer | 99 bottles of beer | Task
Display the complete lyrics for the song: 99 Bottles of Beer on the Wall.
The beer song
The lyrics follow this form:
99 bottles of beer on the wall
99 bottles of beer
Take one down, pass it around
98 bottles of beer on the wall
98 bottles of beer on the wall
98 bottles of beer
Take one down, pass it around
97 bottles of beer on the wall
... and so on, until reaching 0 (zero).
Grammatical support for 1 bottle of beer is optional.
As with any puzzle, try to do it in as creative/concise/comical a way
as possible (simple, obvious solutions allowed, too).
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
See also
http://99-bottles-of-beer.net/
Category:99_Bottles_of_Beer
Category:Programming language families
Wikipedia 99 bottles of beer
| #App_Inventor | App Inventor | repeat with beerCount from 99 to 1 by -1
set bottles to "bottles"
if beerCount < 99 then
if beerCount = 1 then
set bottles to "bottle"
end
log "" & beerCount & " " & bottles & " of beer on the wall"
log ""
end
log "" & beerCount & " " & bottles & " of beer on the wall"
log "" & beerCount & " " & bottles & " of beer"
log "Take one down, pass it around"
end
log "No more bottles of beer on the wall!" |
http://rosettacode.org/wiki/24_game | 24 game | The 24 Game tests one's mental arithmetic.
Task
Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
The goal is for the player to enter an expression that (numerically) evaluates to 24.
Only the following operators/functions are allowed: multiplication, division, addition, subtraction
Division should use floating point or rational arithmetic, etc, to preserve remainders.
Brackets are allowed, if using an infix expression evaluator.
Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
The order of the digits when given does not have to be preserved.
Notes
The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
The task is not for the program to generate the expression, or test whether an expression is even possible.
Related tasks
24 game/Solve
Reference
The 24 Game on h2g2.
| #Erlang | Erlang | -module(g24).
-export([main/0]).
main() ->
random:seed(now()),
io:format("24 Game~n"),
play().
play() ->
io:format("Generating 4 digits...~n"),
Digts = [random:uniform(X) || X <- [9,9,9,9]],
io:format("Your digits\t~w~n", [Digts]),
read_eval(Digts),
play().
read_eval(Digits) ->
Exp = string:strip(io:get_line(standard_io, "Your expression: "), both, $\n),
case {correct_nums(Exp, Digits), eval(Exp)} of
{ok, X} when X == 24 -> io:format("You Win!~n");
{ok, X} -> io:format("You Lose with ~p!~n",[X]);
{List, _} -> io:format("The following numbers are wrong: ~p~n", [List])
end.
correct_nums(Exp, Digits) ->
case re:run(Exp, "([0-9]+)", [global, {capture, all_but_first, list}]) of
nomatch ->
"No number entered";
{match, IntLs} ->
case [X || [X] <- IntLs, not lists:member(list_to_integer(X), Digits)] of
[] -> ok;
L -> L
end
end.
eval(Exp) ->
{X, _} = eval(re:replace(Exp, "\\s", "", [{return, list},global]),
0),
X.
eval([], Val) ->
{Val,[]};
eval([$(|Rest], Val) ->
{NewVal, Exp} = eval(Rest, Val),
eval(Exp, NewVal);
eval([$)|Rest], Val) ->
{Val, Rest};
eval([$[|Rest], Val) ->
{NewVal, Exp} = eval(Rest, Val),
eval(Exp, NewVal);
eval([$]|Rest], Val) ->
{Val, Rest};
eval([$+|Rest], Val) ->
{NewOperand, Exp} = eval(Rest, 0),
eval(Exp, Val + NewOperand);
eval([$-|Rest], Val) ->
{NewOperand, Exp} = eval(Rest, 0),
eval(Exp, Val - NewOperand);
eval([$*|Rest], Val) ->
{NewOperand, Exp} = eval(Rest, 0),
eval(Exp, Val * NewOperand);
eval([$/|Rest], Val) ->
{NewOperand, Exp} = eval(Rest, 0),
eval(Exp, Val / NewOperand);
eval([X|Rest], 0) when X >= $1, X =< $9 ->
eval(Rest, X-$0).
|
http://rosettacode.org/wiki/A%2BB | A+B | A+B ─── a classic problem in programming contests, it's given so contestants can gain familiarity with the online judging system being used.
Task
Given two integers, A and B.
Their sum needs to be calculated.
Input data
Two integers are written in the input stream, separated by space(s):
(
−
1000
≤
A
,
B
≤
+
1000
)
{\displaystyle (-1000\leq A,B\leq +1000)}
Output data
The required output is one integer: the sum of A and B.
Example
input
output
2 2
4
3 2
5
| #CoffeeScript | CoffeeScript | <html>
<script type="text/javascript" src="http://jashkenas.github.com/coffee-script/extras/coffee-script.js"></script>
<script type="text/coffeescript">
a = window.prompt 'enter A number', ''
b = window.prompt 'enter B number', ''
document.getElementById('input').innerHTML = a + ' ' + b
sum = parseInt(a) + parseInt(b)
document.getElementById('output').innerHTML = sum
</script>
<body>
<div id='input'></div>
<div id='output'></div>
</body>
</html> |
http://rosettacode.org/wiki/Ackermann_function | Ackermann function | The Ackermann function is a classic example of a recursive function, notable especially because it is not a primitive recursive function. It grows very quickly in value, as does the size of its call tree.
The Ackermann function is usually defined as follows:
A
(
m
,
n
)
=
{
n
+
1
if
m
=
0
A
(
m
−
1
,
1
)
if
m
>
0
and
n
=
0
A
(
m
−
1
,
A
(
m
,
n
−
1
)
)
if
m
>
0
and
n
>
0.
{\displaystyle A(m,n)={\begin{cases}n+1&{\mbox{if }}m=0\\A(m-1,1)&{\mbox{if }}m>0{\mbox{ and }}n=0\\A(m-1,A(m,n-1))&{\mbox{if }}m>0{\mbox{ and }}n>0.\end{cases}}}
Its arguments are never negative and it always terminates.
Task
Write a function which returns the value of
A
(
m
,
n
)
{\displaystyle A(m,n)}
. Arbitrary precision is preferred (since the function grows so quickly), but not required.
See also
Conway chained arrow notation for the Ackermann function.
| #V | V | [ack
[ [pop zero?] [popd succ]
[zero?] [pop pred 1 ack]
[true] [[dup pred swap] dip pred ack ack ]
] when]. |
http://rosettacode.org/wiki/ABC_problem | ABC problem | ABC problem
You are encouraged to solve this task according to the task description, using any language you may know.
You are given a collection of ABC blocks (maybe like the ones you had when you were a kid).
There are twenty blocks with two letters on each block.
A complete alphabet is guaranteed amongst all sides of the blocks.
The sample collection of blocks:
(B O)
(X K)
(D Q)
(C P)
(N A)
(G T)
(R E)
(T G)
(Q D)
(F S)
(J W)
(H U)
(V I)
(A N)
(O B)
(E R)
(F S)
(L Y)
(P C)
(Z M)
Task
Write a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.
The rules are simple:
Once a letter on a block is used that block cannot be used again
The function should be case-insensitive
Show the output on this page for the following 7 words in the following example
Example
>>> can_make_word("A")
True
>>> can_make_word("BARK")
True
>>> can_make_word("BOOK")
False
>>> can_make_word("TREAT")
True
>>> can_make_word("COMMON")
False
>>> can_make_word("SQUAD")
True
>>> can_make_word("CONFUSE")
True
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
| #FreeBASIC | FreeBASIC | ' version 28-01-2019
' compile with: fbc -s console
Dim As String blocks(1 To 20, 1 To 2) => {{"B", "O"}, {"X", "K"}, {"D", "Q"}, _
{"C", "P"}, {"N", "A"}, {"G", "T"}, {"R", "E"}, {"T", "G"}, {"Q", "D"}, _
{"F", "S"}, {"J", "W"}, {"H", "U"}, {"V", "I"}, {"A", "N"}, {"O", "B"}, _
{"E", "R"}, {"F", "S"}, {"L", "Y"}, {"P", "C"}, {"Z", "M"}}
Dim As UInteger i, x, y, b()
Dim As String word, char
Dim As boolean possible
Do
Read word
If word = "" Then Exit Do
word = UCase(word)
ReDim b(1 To 20)
possible = TRUE
For i = 1 To Len(word)
char = Mid(word, i, 1)
For x = 1 To 20
If b(x) = 0 Then
If blocks(x, 1) = char Or blocks(x, 2) = char Then
b(x) = 1
Exit For
End If
End If
Next
If x = 21 Then possible = FALSE
Next
Print word, possible
Loop
Data "A", "Bark", "Book", "Treat", "Common", "Squad", "Confuse", ""
' empty keyboard buffer
While InKey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End |
http://rosettacode.org/wiki/100_prisoners | 100 prisoners |
The Problem
100 prisoners are individually numbered 1 to 100
A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.
Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.
Prisoners start outside the room
They can decide some strategy before any enter the room.
Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.
A prisoner can open no more than 50 drawers.
A prisoner tries to find his own number.
A prisoner finding his own number is then held apart from the others.
If all 100 prisoners find their own numbers then they will all be pardoned. If any don't then all sentences stand.
The task
Simulate several thousand instances of the game where the prisoners randomly open drawers
Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:
First opening the drawer whose outside number is his prisoner number.
If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).
Show and compare the computed probabilities of success for the two strategies, here, on this page.
References
The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).
wp:100 prisoners problem
100 Prisoners Escape Puzzle DataGenetics.
Random permutation statistics#One hundred prisoners on Wikipedia.
| #EasyLang | EasyLang | for i range 100
drawer[] &= i
sampler[] &= i
.
subr shuffle_drawer
for i = len drawer[] downto 2
r = random i
swap drawer[r] drawer[i - 1]
.
.
subr play_random
call shuffle_drawer
found = 1
prisoner = 0
while prisoner < 100 and found = 1
found = 0
i = 0
while i < 50 and found = 0
r = random (100 - i)
card = drawer[sampler[r]]
swap sampler[r] sampler[100 - i - 1]
if card = prisoner
found = 1
.
i += 1
.
prisoner += 1
.
.
subr play_optimal
call shuffle_drawer
found = 1
prisoner = 0
while prisoner < 100 and found = 1
reveal = prisoner
found = 0
i = 0
while i < 50 and found = 0
card = drawer[reveal]
if card = prisoner
found = 1
.
reveal = card
i += 1
.
prisoner += 1
.
.
n = 10000
pardoned = 0
for round range n
call play_random
pardoned += found
.
print "random: " & 100.0 * pardoned / n & "%"
#
pardoned = 0
for round range n
call play_optimal
pardoned += found
.
print "optimal: " & 100.0 * pardoned / n & "%" |
http://rosettacode.org/wiki/Abundant_odd_numbers | Abundant odd numbers | An Abundant number is a number n for which the sum of divisors σ(n) > 2n,
or, equivalently, the sum of proper divisors (or aliquot sum) s(n) > n.
E.G.
12 is abundant, it has the proper divisors 1,2,3,4 & 6 which sum to 16 ( > 12 or n);
or alternately, has the sigma sum of 1,2,3,4,6 & 12 which sum to 28 ( > 24 or 2n).
Abundant numbers are common, though even abundant numbers seem to be much more common than odd abundant numbers.
To make things more interesting, this task is specifically about finding odd abundant numbers.
Task
Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.
Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.
Find and display here: the first abundant odd number greater than one billion (109) and either its proper divisor sum or sigma sum.
References
OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)
American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)
| #X86_Assembly | X86 Assembly | .model tiny
.code
.486
org 100h
;ebp=counter, edi=Num, ebx=Div, esi=Sum
start: xor ebp, ebp ;odd abundant number counter:= 0
mov edi, 3 ;Num:= 3
ab10: mov ebx, 3 ;Div:= 3
mov esi, 1 ;Sum:= 1
ab20: mov eax, edi ;Quot:= Num/Div
cdq ;edx:= 0
div ebx ;eax(q):edx(r):= edx:eax/ebx
cmp ebx, eax ;if Div > Quot then quit loop
jge ab50
test edx, edx ;if remainder = 0 then
jne ab30
add esi, ebx ; Sum:= Sum + Div
cmp ebx, eax ; if Div # Quot then
je ab30
add esi, eax ; Sum:= Sum + Quot
ab30: add ebx, 2 ;Div:= Div+2 (only check odd Nums)
jmp ab20 ;loop
ab50:
cmp esi, edi ;if Sum > Num then
jle ab80
inc ebp ; counter:= counter+1
cmp ebp, 25 ; if counter<=25 or counter>=1000 then
jle ab60
cmp ebp, 1000
jl ab80
ab60: mov eax, edi ; print Num
call numout
mov al, ' ' ; print spaces
int 29h
int 29h
mov eax, esi ; print Sum
call numout
mov al, 0Dh ; carriage return
int 29h
mov al, 0Ah ; line feed
int 29h
cmp ebp, 1000 ; if counter = 1000 then
jne ab65
mov edi, 1000000001-2 ; Num:= 1,000,000,001 - 2
ab65: cmp edi, 1000000000 ; if Num > 1,000,000,000 then exit
jg ab90
ab80: add edi, 2 ;Num:= Num+2 (only check odd Nums)
jmp ab10 ;loop
ab90: ret
;Print signed integer in eax with commas, e.g: 12,345,010
numout: xor ecx, ecx ;digit counter:= 0
no00: cdq ;edx:= 0
mov ebx, 10 ;Num:= Num/10
div ebx ;eax(q):edx(r):= edx:eax/ebx
push edx ;remainder = least significant digit
inc ecx ;count digit
test eax, eax ;if Num # 0 then NumOut(Num)
je no20
call no00
no20: pop eax ;print digit + '0'
add al, '0'
int 29h
dec ecx ;un-count digit
je no30 ;if counter # 0 and
mov al, cl ; if remainder(counter/3) = 0 then
aam 3
jne no30
mov al, ',' ; print ','
int 29h
no30: ret
end start |
http://rosettacode.org/wiki/21_game | 21 game | 21 game
You are encouraged to solve this task according to the task description, using any language you may know.
21 is a two player game, the game is played by choosing
a number (1, 2, or 3) to be added to the running total.
The game is won by the player whose chosen number causes the running total
to reach exactly 21.
The running total starts at zero.
One player will be the computer.
Players alternate supplying a number to be added to the running total.
Task
Write a computer program that will:
do the prompting (or provide a button menu),
check for errors and display appropriate error messages,
do the additions (add a chosen number to the running total),
display the running total,
provide a mechanism for the player to quit/exit/halt/stop/close the program,
issue a notification when there is a winner, and
determine who goes first (maybe a random or user choice, or can be specified when the game begins).
| #Racket | Racket | #lang racket
(define limit 21)
(define max-resp 3)
(define (get-resp)
(let loop ()
(match (read-line)
[(app (conjoin string? string->number) n)
#:when (and (exact-integer? n) (<= 1 n max-resp))
n]
["q" (exit)]
[n (printf "~a is not in range 1 and ~a\n" n max-resp)
(loop)])))
(define (win human?) (printf "~a wins\n" (if human? "Human" "Computer")))
(printf "The ~a game. Each player chooses to add a number
in range 1 and ~a to a running total.
The player whose turn it is when the total reaches exactly ~a wins.
Enter q to quit.\n\n" limit max-resp limit)
(let loop ([total 0] [human-turn? (= 0 (random 2))])
(define new-total
(+ total
(cond
[human-turn? (printf "Running total is: ~a\n" total)
(printf "Your turn:\n")
(get-resp)]
[else (define resp (random 1 (add1 max-resp)))
(printf "Computer plays: ~a\n" resp)
resp])))
(cond
[(= new-total limit) (win human-turn?)]
[(> new-total limit) (win (not human-turn?))]
[else (loop new-total (not human-turn?))])) |
http://rosettacode.org/wiki/24_game/Solve | 24 game/Solve | task
Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the 24 game.
Show examples of solutions generated by the program.
Related task
Arithmetic Evaluator
| #Haskell | Haskell | import Data.List
import Data.Ratio
import Control.Monad
import System.Environment (getArgs)
data Expr = Constant Rational |
Expr :+ Expr | Expr :- Expr |
Expr :* Expr | Expr :/ Expr
deriving (Eq)
ops = [(:+), (:-), (:*), (:/)]
instance Show Expr where
show (Constant x) = show $ numerator x
-- In this program, we need only print integers.
show (a :+ b) = strexp "+" a b
show (a :- b) = strexp "-" a b
show (a :* b) = strexp "*" a b
show (a :/ b) = strexp "/" a b
strexp :: String -> Expr -> Expr -> String
strexp op a b = "(" ++ show a ++ " " ++ op ++ " " ++ show b ++ ")"
templates :: [[Expr] -> Expr]
templates = do
op1 <- ops
op2 <- ops
op3 <- ops
[\[a, b, c, d] -> op1 a $ op2 b $ op3 c d,
\[a, b, c, d] -> op1 (op2 a b) $ op3 c d,
\[a, b, c, d] -> op1 a $ op2 (op3 b c) d,
\[a, b, c, d] -> op1 (op2 a $ op3 b c) d,
\[a, b, c, d] -> op1 (op2 (op3 a b) c) d]
eval :: Expr -> Maybe Rational
eval (Constant c) = Just c
eval (a :+ b) = liftM2 (+) (eval a) (eval b)
eval (a :- b) = liftM2 (-) (eval a) (eval b)
eval (a :* b) = liftM2 (*) (eval a) (eval b)
eval (a :/ b) = do
denom <- eval b
guard $ denom /= 0
liftM (/ denom) $ eval a
solve :: Rational -> [Rational] -> [Expr]
solve target r4 = filter (maybe False (== target) . eval) $
liftM2 ($) templates $
nub $ permutations $ map Constant r4
main = getArgs >>= mapM_ print . solve 24 . map (toEnum . read) |
http://rosettacode.org/wiki/15_puzzle_game | 15 puzzle game |
Task
Implement the Fifteen Puzzle Game.
The 15-puzzle is also known as:
Fifteen Puzzle
Gem Puzzle
Boss Puzzle
Game of Fifteen
Mystic Square
14-15 Puzzle
and some others.
Related Tasks
15 Puzzle Solver
16 Puzzle Game
| #APL | APL | fpg←{⎕IO←0
⍺←4 4
(s∨.<0)∨2≠⍴s←⍺:'invalid shape:'s
0≠⍴⍴⍵:'invalid shuffle count:'⍵
d←d,-d←↓2 2⍴3↑1
e←¯1+⍴c←'↑↓←→○'
b←w←s⍴w←1⌽⍳×/s
z←⊃{
z p←⍵
n←(?⍴p)⊃p←(p≡¨(⊂s)|p)/p←(d~p)+⊂z
b[z n]←b[n z]
-⍨\n z
}⍣⍵⊢(s-1)0
⎕←b
⍬{
b≡w:'win'
0=⍴⍺:⍞∇ ⍵
e=i←c⍳m←⊃⍺:'quit'
i>e:⍞∇ ⍵⊣⎕←'invalid direction:'m
n≢s|n←⍵+i⊃d:⍞∇ ⍵⊣'out of bounds:'m
b[⍵ n]←b[n ⍵]
⎕←(s×0≠⍴⍺)⍴b
(1↓⍺)∇ n
}z
} |
http://rosettacode.org/wiki/2048 | 2048 | Task
Implement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.
Rules of the game
The rules are that on each turn the player must choose a direction (up, down, left or right).
All tiles move as far as possible in that direction, some move more than others.
Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.
A move is valid when at least one tile can be moved, if only by combination.
A new tile with the value of 2 is spawned at the end of each turn at a randomly chosen empty square (if there is one).
Adding a new tile on a blank space. Most of the time, a new 2 is to be added, and occasionally (10% of the time), a 4.
To win, the player must create a tile with the number 2048.
The player loses if no valid moves are possible.
The name comes from the popular open-source implementation of this game mechanic, 2048.
Requirements
"Non-greedy" movement.
The tiles that were created by combining other tiles should not be combined again during the same turn (move).
That is to say, that moving the tile row of:
[2][2][2][2]
to the right should result in:
......[4][4]
and not:
.........[8]
"Move direction priority".
If more than one variant of combining is possible, move direction shall indicate which combination will take effect.
For example, moving the tile row of:
...[2][2][2]
to the right should result in:
......[2][4]
and not:
......[4][2]
Check for valid moves. The player shouldn't be able to skip their turn by trying a move that doesn't change the board.
Check for a win condition.
Check for a lose condition.
| #C | C |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>
#define D_INVALID -1
#define D_UP 1
#define D_DOWN 2
#define D_RIGHT 3
#define D_LEFT 4
const long values[] = {
0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048
};
const char *colors[] = {
"39", "31", "32", "33", "34", "35", "36", "37", "91", "92", "93", "94"
};
struct gamestate_struct__ {
int grid[4][4];
int have_moved;
long total_score;
long score_last_move;
int blocks_in_play;
} game;
struct termios oldt, newt;
void do_draw(void)
{
printf("\033[2J\033[HScore: %ld", game.total_score);
if (game.score_last_move)
printf(" (+%ld)", game.score_last_move);
printf("\n");
for (int i = 0; i < 25; ++i)
printf("-");
printf("\n");
for (int y = 0; y < 4; ++y) {
printf("|");
for (int x = 0; x < 4; ++x) {
if (game.grid[x][y])
printf("\033[7m\033[%sm%*zd \033[0m|", colors[game.grid[x][y]],
4, values[game.grid[x][y]]);
else
printf("%*s |", 4, "");
}
printf("\n");
}
for (int i = 0; i < 25; ++i) {
printf("-");
}
printf("\n");
}
void do_merge(int d)
{
/* These macros look pretty scary, but mainly demonstrate some space saving */
#define MERGE_DIRECTION(_v1, _v2, _xs, _xc, _xi, _ys, _yc, _yi, _x, _y) \
do { \
for (int _v1 = _xs; _v1 _xc; _v1 += _xi) { \
for (int _v2 = _ys; _v2 _yc; _v2 += _yi) { \
if (game.grid[x][y] && (game.grid[x][y] == \
game.grid[x + _x][y + _y])) { \
game.grid[x][y] += (game.have_moved = 1); \
game.grid[x + _x][y + _y] = (0 * game.blocks_in_play--);\
game.score_last_move += values[game.grid[x][y]]; \
game.total_score += values[game.grid[x][y]]; \
} \
} \
} \
} while (0)
game.score_last_move = 0;
switch (d) {
case D_LEFT:
MERGE_DIRECTION(x, y, 0, < 3, 1, 0, < 4, 1, 1, 0);
break;
case D_RIGHT:
MERGE_DIRECTION(x, y, 3, > 0, -1, 0, < 4, 1, -1, 0);
break;
case D_DOWN:
MERGE_DIRECTION(y, x, 3, > 0, -1, 0, < 4, 1, 0, -1);
break;
case D_UP:
MERGE_DIRECTION(y, x, 0, < 3, 1, 0, < 4, 1, 0, 1);
break;
}
#undef MERGE_DIRECTION
}
void do_gravity(int d)
{
#define GRAVITATE_DIRECTION(_v1, _v2, _xs, _xc, _xi, _ys, _yc, _yi, _x, _y) \
do { \
int break_cond = 0; \
while (!break_cond) { \
break_cond = 1; \
for (int _v1 = _xs; _v1 _xc; _v1 += _xi) { \
for (int _v2 = _ys; _v2 _yc; _v2 += _yi) { \
if (!game.grid[x][y] && game.grid[x + _x][y + _y]) { \
game.grid[x][y] = game.grid[x + _x][y + _y]; \
game.grid[x + _x][y + _y] = break_cond = 0; \
game.have_moved = 1; \
} \
} \
} \
do_draw(); usleep(40000); \
} \
} while (0)
switch (d) {
case D_LEFT:
GRAVITATE_DIRECTION(x, y, 0, < 3, 1, 0, < 4, 1, 1, 0);
break;
case D_RIGHT:
GRAVITATE_DIRECTION(x, y, 3, > 0, -1, 0, < 4, 1, -1, 0);
break;
case D_DOWN:
GRAVITATE_DIRECTION(y, x, 3, > 0, -1, 0, < 4, 1, 0, -1);
break;
case D_UP:
GRAVITATE_DIRECTION(y, x, 0, < 3, 1, 0, < 4, 1, 0, 1);
break;
}
#undef GRAVITATE_DIRECTION
}
int do_check_end_condition(void)
{
int ret = -1;
for (int x = 0; x < 4; ++x) {
for (int y = 0; y < 4; ++y) {
if (values[game.grid[x][y]] == 2048)
return 1;
if (!game.grid[x][y] ||
((x + 1 < 4) && (game.grid[x][y] == game.grid[x + 1][y])) ||
((y + 1 < 4) && (game.grid[x][y] == game.grid[x][y + 1])))
ret = 0;
}
}
return ret;
}
int do_tick(int d)
{
game.have_moved = 0;
do_gravity(d);
do_merge(d);
do_gravity(d);
return game.have_moved;
}
void do_newblock(void) {
if (game.blocks_in_play >= 16) return;
int bn = rand() % (16 - game.blocks_in_play);
int pn = 0;
for (int x = 0; x < 4; ++x) {
for (int y = 0; y < 4; ++y) {
if (game.grid[x][y])
continue;
if (pn == bn){
game.grid[x][y] = rand() % 10 ? 1 : 2;
game.blocks_in_play += 1;
return;
}
else {
++pn;
}
}
}
}
int main(void)
{
/* Initialize terminal settings */
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
srand(time(NULL));
memset(&game, 0, sizeof(game));
do_newblock();
do_newblock();
do_draw();
while (1) {
int found_valid_key, direction, value;
do {
found_valid_key = 1;
direction = D_INVALID;
value = getchar();
switch (value) {
case 'h': case 'a':
direction = D_LEFT;
break;
case 'l': case 'd':
direction = D_RIGHT;
break;
case 'j': case 's':
direction = D_DOWN;
break;
case 'k': case 'w':
direction = D_UP;
break;
case 'q':
goto game_quit;
break;
case 27:
if (getchar() == 91) {
value = getchar();
switch (value) {
case 65:
direction = D_UP;
break;
case 66:
direction = D_DOWN;
break;
case 67:
direction = D_RIGHT;
break;
case 68:
direction = D_LEFT;
break;
default:
found_valid_key = 0;
break;
}
}
break;
default:
found_valid_key = 0;
break;
}
} while (!found_valid_key);
do_tick(direction);
if (game.have_moved != 0){
do_newblock();
}
do_draw();
switch (do_check_end_condition()) {
case -1:
goto game_lose;
case 1:
goto game_win;
case 0:
break;
}
}
if (0)
game_lose:
printf("You lose!\n");
goto game_quit;
if (0)
game_win:
printf("You win!\n");
goto game_quit;
if (0)
game_quit:
/* Restore terminal settings */
tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
return 0;
}
|
http://rosettacode.org/wiki/4-rings_or_4-squares_puzzle | 4-rings or 4-squares puzzle | 4-rings or 4-squares puzzle
You are encouraged to solve this task according to the task description, using any language you may know.
Task
Replace a, b, c, d, e, f, and
g with the decimal
digits LOW ───► HIGH
such that the sum of the letters inside of each of the four large squares add up to
the same sum.
╔══════════════╗ ╔══════════════╗
║ ║ ║ ║
║ a ║ ║ e ║
║ ║ ║ ║
║ ┌───╫──────╫───┐ ┌───╫─────────┐
║ │ ║ ║ │ │ ║ │
║ │ b ║ ║ d │ │ f ║ │
║ │ ║ ║ │ │ ║ │
║ │ ║ ║ │ │ ║ │
╚══════════╪═══╝ ╚═══╪══════╪═══╝ │
│ c │ │ g │
│ │ │ │
│ │ │ │
└──────────────┘ └─────────────┘
Show all output here.
Show all solutions for each letter being unique with
LOW=1 HIGH=7
Show all solutions for each letter being unique with
LOW=3 HIGH=9
Show only the number of solutions when each letter can be non-unique
LOW=0 HIGH=9
Related task
Solve the no connection puzzle
| #REXX | REXX | /*REXX pgm solves the 4-rings puzzle, where letters represent unique (or not) digits). */
arg LO HI unique show . /*the ARG statement capitalizes args.*/
if LO=='' | LO=="," then LO=1 /*Not specified? Then use the default.*/
if HI=='' | HI=="," then HI=7 /* " " " " " " */
if unique=='' | unique==',' | unique=='UNIQUE' then unique=1 /*unique letter solutions*/
else unique=0 /*non-unique " */
if show=='' | show==',' | show=='SHOW' then show=1 /*noshow letter solutions*/
else show=0 /* show " " */
w=max(3, length(LO), length(HI) ) /*maximum width of any number found. */
bar=copies('═', w) /*define a horizontal bar (for title). */
times=HI - LO + 1 /*calculate number of times to loop. */
#=0 /*number of solutions found (so far). */
do a=LO for times
do b=LO for times
if unique then if b==a then iterate
do c=LO for times
if unique then do; if c==a then iterate
if c==b then iterate
end
do d=LO for times
if unique then do; if d==a then iterate
if d==b then iterate
if d==c then iterate
end
do e=LO for times
if unique then do; if e==a then iterate
if e==b then iterate
if e==c then iterate
if e==d then iterate
end
do f=LO for times
if unique then do; if f==a then iterate
if f==b then iterate
if f==c then iterate
if f==d then iterate
if f==e then iterate
end
do g=LO for times
if unique then do; if g==a then iterate
if g==b then iterate
if g==c then iterate
if g==d then iterate
if g==e then iterate
if g==f then iterate
end
sum=a+b
if f+g\==sum then iterate
if b+c+d\==sum then iterate
if d+e+f\==sum then iterate
#=# + 1 /*bump the count of solutions.*/
if #==1 then call align 'a', 'b', 'c', 'd', 'e', 'f', 'g'
if #==1 then call align bar, bar, bar, bar, bar, bar, bar
call align a, b, c, d, e, f, g
end /*g*/
end /*f*/
end /*e*/
end /*d*/
end /*c*/
end /*b*/
end /*a*/
say
_= ' non-unique'
if unique then _= ' unique '
say # _ 'solutions found.'
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
align: parse arg a1,a2,a3,a4,a5,a6,a7
if show then say left('',9) center(a1,w) center(a2,w) center(a3,w) center(a4,w),
center(a5,w) center(a6,w) center(a7,w)
return |
http://rosettacode.org/wiki/15_puzzle_solver | 15 puzzle solver | Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.
For this task you will be using the following puzzle:
15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
The output must show the moves' directions, like so: left, left, left, down, right... and so on.
There are two solutions, of fifty-two moves:
rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd
rrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd
see: Pretty Print of Optimal Solution
Finding either one, or both is an acceptable result.
Extra credit.
Solve the following problem:
0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1
Related Task
15 puzzle game
A* search algorithm
| #Julia | Julia | const Nr = [3, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3]
const Nc = [3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2]
const N0 = zeros(Int, 85)
const N2 = zeros(UInt64, 85)
const N3 = zeros(UInt8, 85)
const N4 = zeros(Int, 85)
const i = 1
const g = 8
const ee = 2
const l = 4
const _n = Vector{Int32}([0])
function fY(n::Int)
if N2[n + 1] == UInt64(0x123456789abcdef0)
return true, n
end
if N4[n + 1] <= _n[1]
return fN(n)
end
false, n
end
function fZ(w, n)
if w & i > 0
n = fI(n)
(y, n) = fY(n)
if y return (true, n) end
n -= 1
end
if w & g > 0
n = fG(n)
(y, n) = fY(n)
if y return (true, n) end
n -= 1
end
if w & ee > 0
n = fE(n)
(y, n) = fY(n)
if y return (true, n) end
n -= 1
end
if w & l > 0
n = fL(n)
(y, n) = fY(n)
if y return (true, n) end
n -= 1
end
false, n
end
function fN(n::Int)
x = N0[n + 1]
y = UInt8(N3[n + 1])
if x == 0
if y == UInt8('l')
return fZ(i, n)
elseif y == UInt8('u')
return fZ(ee, n)
else
return fZ(i + ee, n)
end
elseif x == 3
if y == UInt8('r')
return fZ(i, n)
elseif y == UInt8('u')
return fZ(l, n)
else
return fZ(i + l, n)
end
elseif x == 1 || x == 2
if y == UInt8('l')
return fZ(i + l, n)
elseif y == UInt8('r')
return fZ(i + ee, n)
elseif y == UInt8('u')
return fZ(ee + l, n)
else
return fZ(l + ee + i, n)
end
elseif x == 12
if y == UInt8('l')
return fZ(g, n)
elseif y == UInt8('d')
return fZ(ee, n)
else
return fZ(ee + g, n)
end
elseif x == 15
if y == UInt8('r')
return fZ(g, n)
elseif y == UInt8('d')
return fZ(l, n)
else
return fZ(g + l, n)
end
elseif x == 13 || x == 14
if y == UInt8('l')
return fZ(g + l, n)
elseif y == UInt8('r')
return fZ(ee + g, n)
elseif y == UInt8('d')
return fZ(ee + l, n)
else
return fZ(g + ee + l, n)
end
elseif x == 4 || x == 8
if y == UInt8('l')
return fZ(i + g, n)
elseif y == UInt8('u')
return fZ(g + ee, n)
elseif y == UInt8('d')
return fZ(i + ee, n)
else
return fZ(i + g + ee, n)
end
elseif x == 7 || x == 11
if y == UInt8('d')
return fZ(i + l, n)
elseif y == UInt8('u')
return fZ(g + l, n)
elseif y == UInt8('r')
return fZ(i + g, n)
else
return fZ(i + g + l, n)
end
else
if y == UInt8('d')
return fZ(i + ee + l, n)
elseif y == UInt8('l')
return fZ(i + g + l, n)
elseif y == UInt8('r')
return fZ(i + g + ee, n)
elseif y == UInt8('u')
return fZ(g + ee + l, n)
else
return fZ(i + g + ee + l, n)
end
end
end
function fI(n)
gg = (11 - N0[n + 1]) * 4
a = N2[n + 1] & (UInt64(0xf) << UInt(gg))
N0[n + 2] = N0[n + 1] + 4
N2[n + 2] = N2[n + 1] - a + (a << 16)
N3[n + 2] = UInt8('d')
N4[n + 2] = N4[n + 1]
cond = Nr[(a >> gg) + 1] <= div(N0[n + 1], 4)
if !cond
N4[n + 2] += 1
end
n += 1
n
end
function fG(n)
gg = (19 - N0[n + 1]) * 4
a = N2[n + 1] & (UInt64(0xf) << UInt(gg))
N0[n + 2] = N0[n + 1] - 4
N2[n + 2] = N2[n + 1] - a + (a >> 16)
N3[n + 2] = UInt8('u')
N4[n + 2] = N4[n + 1]
cond = Nr[(a >> gg) + 1] >= div(N0[n + 1], 4)
if !cond
N4[n + 2] += 1
end
n += 1
n
end
function fE(n)
gg = (14 - N0[n + 1]) * 4
a = N2[n + 1] & (UInt64(0xf) << UInt(gg))
N0[n + 2] = N0[n + 1] + 1
N2[n + 2] = N2[n + 1] - a + (a << 4)
N3[n + 2] = UInt8('r')
N4[n + 2] = N4[n + 1]
cond = Nc[(a >> gg) + 1] <= N0[n + 1] % 4
if !cond
N4[n + 2] += 1
end
n += 1
n
end
function fL(n)
gg = (16 - N0[n + 1]) * 4
a = N2[n + 1] & (UInt64(0xf) << UInt(gg))
N0[n + 2] = N0[n + 1] - 1
N2[n + 2] = N2[n + 1] - a + (a >> 4)
N3[n + 2] = UInt8('l')
N4[n + 2] = N4[n + 1]
cond = Nc[(a >> gg) + 1] >= N0[n + 1] % 4
if !cond
N4[n + 2] += 1
end
n += 1
n
end
function solve(n)
ans, n = fN(n)
if ans
println("Solution found in $n moves: ")
for ch in N3[2:n+1] print(Char(ch)) end; println()
else
println("next iteration, _n[1] will be $(_n[1] + 1)...")
n = 0; _n[1] += 1; solve(n)
end
end
run() = (N0[1] = 8; _n[1] = 1; N2[1] = 0xfe169b4c0a73d852; solve(0))
run()
|
http://rosettacode.org/wiki/99_bottles_of_beer | 99 bottles of beer | Task
Display the complete lyrics for the song: 99 Bottles of Beer on the Wall.
The beer song
The lyrics follow this form:
99 bottles of beer on the wall
99 bottles of beer
Take one down, pass it around
98 bottles of beer on the wall
98 bottles of beer on the wall
98 bottles of beer
Take one down, pass it around
97 bottles of beer on the wall
... and so on, until reaching 0 (zero).
Grammatical support for 1 bottle of beer is optional.
As with any puzzle, try to do it in as creative/concise/comical a way
as possible (simple, obvious solutions allowed, too).
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
See also
http://99-bottles-of-beer.net/
Category:99_Bottles_of_Beer
Category:Programming language families
Wikipedia 99 bottles of beer
| #AppleScript | AppleScript | repeat with beerCount from 99 to 1 by -1
set bottles to "bottles"
if beerCount < 99 then
if beerCount = 1 then
set bottles to "bottle"
end
log "" & beerCount & " " & bottles & " of beer on the wall"
log ""
end
log "" & beerCount & " " & bottles & " of beer on the wall"
log "" & beerCount & " " & bottles & " of beer"
log "Take one down, pass it around"
end
log "No more bottles of beer on the wall!" |
http://rosettacode.org/wiki/24_game | 24 game | The 24 Game tests one's mental arithmetic.
Task
Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
The goal is for the player to enter an expression that (numerically) evaluates to 24.
Only the following operators/functions are allowed: multiplication, division, addition, subtraction
Division should use floating point or rational arithmetic, etc, to preserve remainders.
Brackets are allowed, if using an infix expression evaluator.
Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
The order of the digits when given does not have to be preserved.
Notes
The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
The task is not for the program to generate the expression, or test whether an expression is even possible.
Related tasks
24 game/Solve
Reference
The 24 Game on h2g2.
| #F.23 | F# | open System
open System.Text.RegularExpressions
// Some utilities
let (|Parse|_|) regex str =
let m = Regex(regex).Match(str)
if m.Success then Some ([for g in m.Groups -> g.Value]) else None
let rec gcd x y = if x = y || x = 0 then y else if x < y then gcd y x else gcd y (x-y)
let abs (x : int) = Math.Abs x
let sign (x: int) = Math.Sign x
let cint s = Int32.Parse(s)
let replace m (s : string) t = Regex.Replace(t, m, s)
// computing in Rationals
type Rat(x : int, y : int) =
let g = if y <> 0 then gcd (abs x) (abs y) else raise <| DivideByZeroException()
member this.n = sign y * x / g // store a minus sign in the numerator
member this.d =
if y <> 0 then sign y * y / g else raise <| DivideByZeroException()
static member (~-) (x : Rat) = Rat(-x.n, x.d)
static member (+) (x : Rat, y : Rat) = Rat(x.n * y.d + y.n * x.d, x.d * y.d)
static member (-) (x : Rat, y : Rat) = x + Rat(-y.n, y.d)
static member (*) (x : Rat, y : Rat) = Rat(x.n * y.n, x.d * y.d)
static member (/) (x : Rat, y : Rat) = x * Rat(y.d, y.n)
override this.ToString() = sprintf @"<%d,%d>" this.n this.d
new(x : string, y : string) = if y = "" then Rat(cint x, 1) else Rat(cint x, cint y)
// Due to the constraints imposed by the game (reduced set
// of operators, all left associativ) we can get away with a repeated reduction
// to evaluate the algebraic expression.
let rec reduce (str :string) =
let eval (x : Rat) (y : Rat) = function
| "*" -> x * y | "/" -> x / y | "+" -> x + y | "-" -> x - y | _ -> failwith "unknown op"
let subst s r = str.Replace(s, r.ToString())
let rstr =
match str with
| Parse @"\(<(-?\d+),(\d+)>([*/+-])<(-?\d+),(\d+)>\)" [matched; xn; xd; op; yn; yd] ->
subst matched <| eval (Rat(xn,xd)) (Rat(yn,yd)) op
| Parse @"<(-?\d+),(\d+)>([*/])<(-?\d+),(\d+)>" [matched; xn; xd; op; yn; yd] ->
subst matched <| eval (Rat(xn,xd)) (Rat(yn,yd)) op
| Parse @"<(-?\d+),(\d+)>([+-])<(-?\d+),(\d+)>" [matched; xn; xd; op; yn; yd] ->
subst matched <| eval (Rat(xn,xd)) (Rat(yn,yd)) op
| Parse @"\(<(-?\d+),(\d+)>\)" [matched; xn; xd] ->
subst matched <| Rat(xn,xd)
| Parse @"(?<!>)-<(-?\d+),(\d+)>" [matched; xn; xd] ->
subst matched <| -Rat(xn,xd)
| _ -> str
if str = rstr then str else reduce rstr
let gameLoop() =
let checkInput dddd input =
match input with
| "n" | "q" -> Some(input)
| Parse @"[^1-9()*/+-]" [c] ->
printfn "You used an illegal character in your expression: %s" c
None
| Parse @"^\D*(\d)\D+(\d)\D+(\d)\D+(\d)(?:\D*(\d))*\D*$" [m; d1; d2; d3; d4; d5] ->
if d5 = "" && (String.Join(" ", Array.sort [|d1;d2;d3;d4|])) = dddd then Some(input)
elif d5 = "" then
printfn "Use this 4 digits with operators in between: %s." dddd
None
else
printfn "Use only this 4 digits with operators in between: %s." dddd
None
| _ ->
printfn "Use all 4 digits with operators in between: %s." dddd
None
let rec userLoop dddd =
let tryAgain msg =
printfn "%s" msg
userLoop dddd
printf "[Expr|n|q]: "
match Console.ReadLine() |> replace @"\s" "" |> checkInput dddd with
| Some(input) ->
let data = input |> replace @"((?<!\d)-)?\d+" @"<$&,1>"
match data with
| "n" -> true | "q" -> false
| _ ->
try
match reduce data with
| Parse @"^<(-?\d+),(\d+)>$" [_; x; y] ->
let n, d = (cint x), (cint y)
if n = 24 then
printfn "Correct!"
true
elif d=1 then tryAgain <| sprintf "Wrong! Value = %d." n
else tryAgain <| sprintf "Wrong! Value = %d/%d." n d
| _ -> tryAgain "Wrong! not a well-formed expression!"
with
| :? System.DivideByZeroException ->
tryAgain "Wrong! Your expression results in a division by zero!"
| ex ->
tryAgain <| sprintf "There is an unforeseen problem with yout input: %s" ex.Message
| None -> userLoop dddd
let random = new Random(DateTime.Now.Millisecond)
let rec loop() =
let dddd = String.Join(" ", Array.init 4 (fun _ -> 1 + random.Next 9) |> Array.sort)
printfn "\nCompute 24 from the following 4 numbers: %s" dddd
printfn "Use them in any order with * / + - and parentheses; n = new numbers; q = quit"
if userLoop dddd then loop()
loop()
gameLoop() |
http://rosettacode.org/wiki/A%2BB | A+B | A+B ─── a classic problem in programming contests, it's given so contestants can gain familiarity with the online judging system being used.
Task
Given two integers, A and B.
Their sum needs to be calculated.
Input data
Two integers are written in the input stream, separated by space(s):
(
−
1000
≤
A
,
B
≤
+
1000
)
{\displaystyle (-1000\leq A,B\leq +1000)}
Output data
The required output is one integer: the sum of A and B.
Example
input
output
2 2
4
3 2
5
| #Common_Lisp | Common Lisp | (write (+ (read) (read))) |
http://rosettacode.org/wiki/Ackermann_function | Ackermann function | The Ackermann function is a classic example of a recursive function, notable especially because it is not a primitive recursive function. It grows very quickly in value, as does the size of its call tree.
The Ackermann function is usually defined as follows:
A
(
m
,
n
)
=
{
n
+
1
if
m
=
0
A
(
m
−
1
,
1
)
if
m
>
0
and
n
=
0
A
(
m
−
1
,
A
(
m
,
n
−
1
)
)
if
m
>
0
and
n
>
0.
{\displaystyle A(m,n)={\begin{cases}n+1&{\mbox{if }}m=0\\A(m-1,1)&{\mbox{if }}m>0{\mbox{ and }}n=0\\A(m-1,A(m,n-1))&{\mbox{if }}m>0{\mbox{ and }}n>0.\end{cases}}}
Its arguments are never negative and it always terminates.
Task
Write a function which returns the value of
A
(
m
,
n
)
{\displaystyle A(m,n)}
. Arbitrary precision is preferred (since the function grows so quickly), but not required.
See also
Conway chained arrow notation for the Ackermann function.
| #Vala | Vala | uint64 ackermann(uint64 m, uint64 n) {
if (m == 0) return n + 1;
if (n == 0) return ackermann(m - 1, 1);
return ackermann(m - 1, ackermann(m, n - 1));
}
void main () {
for (uint64 m = 0; m < 4; ++m) {
for (uint64 n = 0; n < 10; ++n) {
print(@"A($m,$n) = $(ackermann(m,n))\n");
}
}
} |
http://rosettacode.org/wiki/ABC_problem | ABC problem | ABC problem
You are encouraged to solve this task according to the task description, using any language you may know.
You are given a collection of ABC blocks (maybe like the ones you had when you were a kid).
There are twenty blocks with two letters on each block.
A complete alphabet is guaranteed amongst all sides of the blocks.
The sample collection of blocks:
(B O)
(X K)
(D Q)
(C P)
(N A)
(G T)
(R E)
(T G)
(Q D)
(F S)
(J W)
(H U)
(V I)
(A N)
(O B)
(E R)
(F S)
(L Y)
(P C)
(Z M)
Task
Write a function that takes a string (word) and determines whether the word can be spelled with the given collection of blocks.
The rules are simple:
Once a letter on a block is used that block cannot be used again
The function should be case-insensitive
Show the output on this page for the following 7 words in the following example
Example
>>> can_make_word("A")
True
>>> can_make_word("BARK")
True
>>> can_make_word("BOOK")
False
>>> can_make_word("TREAT")
True
>>> can_make_word("COMMON")
False
>>> can_make_word("SQUAD")
True
>>> can_make_word("CONFUSE")
True
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
| #Gambas | Gambas | Public Sub Main()
Dim sCheck As String[] = ["A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSE"]
Dim sBlock As String[] = ["BO", "XK", "DQ", "CP", "NA", "GT", "RE", "TG", "QD", "FS", "JW", "HU", "VI", "AN", "OB", "ER", "FS", "LY", "PC", "ZM"]
Dim sList As New String[]
Dim siCount, siLoop As Short
Dim sTemp, sAnswer As String
For Each sTemp In sCheck
sAnswer = ""
sList = sBlock.Copy()
For siCount = 1 To Len(sTemp)
For siLoop = 0 To sList.Max
If InStr(sList[siLoop], Mid(sTemp, siCount, 1)) Then
sList.Extract(siLoop, 1)
sAnswer &= Mid(sTemp, siCount, 1)
Break
Endif
Next
Next
If sAnswer = sTemp Then
Print sTemp & " - True"
Else
Print sTemp & " - False"
End If
Next
End |
http://rosettacode.org/wiki/100_prisoners | 100 prisoners |
The Problem
100 prisoners are individually numbered 1 to 100
A room having a cupboard of 100 opaque drawers numbered 1 to 100, that cannot be seen from outside.
Cards numbered 1 to 100 are placed randomly, one to a drawer, and the drawers all closed; at the start.
Prisoners start outside the room
They can decide some strategy before any enter the room.
Prisoners enter the room one by one, can open a drawer, inspect the card number in the drawer, then close the drawer.
A prisoner can open no more than 50 drawers.
A prisoner tries to find his own number.
A prisoner finding his own number is then held apart from the others.
If all 100 prisoners find their own numbers then they will all be pardoned. If any don't then all sentences stand.
The task
Simulate several thousand instances of the game where the prisoners randomly open drawers
Simulate several thousand instances of the game where the prisoners use the optimal strategy mentioned in the Wikipedia article, of:
First opening the drawer whose outside number is his prisoner number.
If the card within has his number then he succeeds otherwise he opens the drawer with the same number as that of the revealed card. (until he opens his maximum).
Show and compare the computed probabilities of success for the two strategies, here, on this page.
References
The unbelievable solution to the 100 prisoner puzzle standupmaths (Video).
wp:100 prisoners problem
100 Prisoners Escape Puzzle DataGenetics.
Random permutation statistics#One hundred prisoners on Wikipedia.
| #Elixir | Elixir | defmodule HundredPrisoners do
def optimal_room(_, _, _, []), do: []
def optimal_room(prisoner, current_room, rooms, [_ | tail]) do
found = Enum.at(rooms, current_room - 1) == prisoner
next_room = Enum.at(rooms, current_room - 1)
[found] ++ optimal_room(prisoner, next_room, rooms, tail)
end
def optimal_search(prisoner, rooms) do
Enum.any?(optimal_room(prisoner, prisoner, rooms, Enum.to_list(1..50)))
end
end
prisoners = 1..100
n = 1..10_000
generate_rooms = fn -> Enum.shuffle(1..100) end
random_strategy = Enum.count(n,
fn _ ->
rooms = generate_rooms.()
Enum.all?(prisoners, fn pr -> pr in (rooms |> Enum.take_random(50)) end)
end)
IO.puts "Random strategy: #{random_strategy} / #{n |> Range.size}"
optimal_strategy = Enum.count(n,
fn _ ->
rooms = generate_rooms.()
Enum.all?(prisoners,
fn pr -> HundredPrisoners.optimal_search(pr, rooms) end)
end)
IO.puts "Optimal strategy: #{optimal_strategy} / #{n |> Range.size}" |
http://rosettacode.org/wiki/Abundant_odd_numbers | Abundant odd numbers | An Abundant number is a number n for which the sum of divisors σ(n) > 2n,
or, equivalently, the sum of proper divisors (or aliquot sum) s(n) > n.
E.G.
12 is abundant, it has the proper divisors 1,2,3,4 & 6 which sum to 16 ( > 12 or n);
or alternately, has the sigma sum of 1,2,3,4,6 & 12 which sum to 28 ( > 24 or 2n).
Abundant numbers are common, though even abundant numbers seem to be much more common than odd abundant numbers.
To make things more interesting, this task is specifically about finding odd abundant numbers.
Task
Find and display here: at least the first 25 abundant odd numbers and either their proper divisor sum or sigma sum.
Find and display here: the one thousandth abundant odd number and either its proper divisor sum or sigma sum.
Find and display here: the first abundant odd number greater than one billion (109) and either its proper divisor sum or sigma sum.
References
OEIS:A005231: Odd abundant numbers (odd numbers n whose sum of divisors exceeds 2n)
American Journal of Mathematics, Vol. 35, No. 4 (Oct., 1913), pp. 413-422 - Finiteness of the Odd Perfect and Primitive Abundant Numbers with n Distinct Prime Factors (LE Dickson)
| #XPL0 | XPL0 | int Cnt, Num, Div, Sum, Quot;
[Cnt:= 0;
Num:= 3; \find odd abundant numbers
loop [Div:= 1;
Sum:= 0;
loop [Quot:= Num/Div;
if Div > Quot then quit;
if rem(0) = 0 then
[Sum:= Sum + Div;
if Div # Quot then Sum:= Sum + Quot;
];
Div:= Div+2;
];
if Sum > 2*Num then
[Cnt:= Cnt+1;
if Cnt<=25 or Cnt>=1000 then
[IntOut(0, Num); ChOut(0, 9);
IntOut(0, Sum); CrLf(0);
if Cnt = 1000 then Num:= 1_000_000_001 - 2;
if Num > 1_000_000_000 then quit;
];
];
Num:= Num+2;
];
] |
http://rosettacode.org/wiki/21_game | 21 game | 21 game
You are encouraged to solve this task according to the task description, using any language you may know.
21 is a two player game, the game is played by choosing
a number (1, 2, or 3) to be added to the running total.
The game is won by the player whose chosen number causes the running total
to reach exactly 21.
The running total starts at zero.
One player will be the computer.
Players alternate supplying a number to be added to the running total.
Task
Write a computer program that will:
do the prompting (or provide a button menu),
check for errors and display appropriate error messages,
do the additions (add a chosen number to the running total),
display the running total,
provide a mechanism for the player to quit/exit/halt/stop/close the program,
issue a notification when there is a winner, and
determine who goes first (maybe a random or user choice, or can be specified when the game begins).
| #Raku | Raku | say qq :to 'HERE';
The 21 game. Each player chooses to add 1, 2, or 3 to a running total.
The player whose turn it is when the total reaches 21 wins. Enter q to quit.
HERE
my $total = 0;
loop {
say "Running total is: $total";
my ($me,$comp);
loop {
$me = prompt 'What number do you play> ';
last if $me ~~ /^<[123]>$/;
insult $me;
}
$total += $me;
win('Human') if $total >= 21;
say "Computer plays: { $comp = (1,2,3).roll }\n";
$total += $comp;
win('Computer') if $total >= 21;
}
sub win ($player) {
say "$player wins.";
exit;
}
sub insult ($g) {
exit if $g eq 'q';
print ('Yo mama,', 'Jeez,', 'Ummmm,', 'Grow up,', 'Did you even READ the instructions?').roll;
say " $g is not an integer between 1 & 3..."
} |
http://rosettacode.org/wiki/24_game/Solve | 24 game/Solve | task
Write a program that takes four digits, either from user input or by random generation, and computes arithmetic expressions following the rules of the 24 game.
Show examples of solutions generated by the program.
Related task
Arithmetic Evaluator
| #Icon_and_Unicon | Icon and Unicon | invocable all
link strings # for csort, deletec, permutes
procedure main()
static eL
initial {
eoP := [] # set-up expression and operator permutation patterns
every ( e := !["a@b#c$d", "a@(b#c)$d", "a@b#(c$d)", "a@(b#c$d)", "a@(b#(c$d))"] ) &
( o := !(opers := "+-*/") || !opers || !opers ) do
put( eoP, map(e,"@#$",o) ) # expr+oper perms
eL := [] # all cases
every ( e := !eoP ) & ( p := permutes("wxyz") ) do
put(eL, map(e,"abcd",p))
}
write("This will attempt to find solutions to 24 for sets of numbers by\n",
"combining 4 single digits between 1 and 9 to make 24 using only + - * / and ( ).\n",
"All operations have equal precedence and are evaluated left to right.\n",
"Enter 'use n1 n2 n3 n4' or just hit enter (to use a random set),",
"'first'/'all' shows the first or all solutions, 'quit' to end.\n\n")
repeat {
e := trim(read()) | fail
e ? case tab(find(" ")|0) of {
"q"|"quit" : break
"u"|"use" : e := tab(0)
"f"|"first": first := 1 & next
"a"|"all" : first := &null & next
"" : e := " " ||(1+?8) || " " || (1+?8) ||" " || (1+?8) || " " || (1+?8)
}
writes("Attempting to solve 24 for",e)
e := deletec(e,' \t') # no whitespace
if e ? ( tab(many('123456789')), pos(5), pos(0) ) then
write(":")
else write(" - invalid, only the digits '1..9' are allowed.") & next
eS := set()
every ex := map(!eL,"wxyz",e) do {
if member(eS,ex) then next # skip duplicates of final expression
insert(eS,ex)
if ex ? (ans := eval(E()), pos(0)) then # parse and evaluate
if ans = 24 then {
write("Success ",image(ex)," evaluates to 24.")
if \first then break
}
}
}
write("Quiting.")
end
procedure eval(X) #: return the evaluated AST
if type(X) == "list" then {
x := eval(get(X))
while o := get(X) do
if y := get(X) then
x := o( real(x), (o ~== "/" | fail, eval(y) ))
else write("Malformed expression.") & fail
}
return \x | X
end
procedure E() #: expression
put(lex := [],T())
while put(lex,tab(any('+-*/'))) do
put(lex,T())
suspend if *lex = 1 then lex[1] else lex # strip useless []
end
procedure T() #: Term
suspend 2(="(", E(), =")") | # parenthesized subexpression, or ...
tab(any(&digits)) # just a value
end |
http://rosettacode.org/wiki/15_puzzle_game | 15 puzzle game |
Task
Implement the Fifteen Puzzle Game.
The 15-puzzle is also known as:
Fifteen Puzzle
Gem Puzzle
Boss Puzzle
Game of Fifteen
Mystic Square
14-15 Puzzle
and some others.
Related Tasks
15 Puzzle Solver
16 Puzzle Game
| #ARM_Assembly | ARM Assembly |
/* ARM assembly Raspberry PI */
/* program puzzle15.s */
/************************************/
/* Constantes */
/************************************/
.equ STDIN, 0 @ Linux input console
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ READ, 3 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
.equ IOCTL, 0x36 @ Linux syscall
.equ SIGACTION, 0x43 @ Linux syscall
.equ SYSPOLL, 0xA8 @ Linux syscall
.equ TCGETS, 0x5401
.equ TCSETS, 0x5402
.equ ICANON, 2
.equ ECHO, 10
.equ POLLIN, 1
.equ SIGINT, 2 @ Issued if the user sends an interrupt signal (Ctrl + C)
.equ SIGQUIT, 3 @ Issued if the user sends a quit signal (Ctrl + D)
.equ SIGTERM, 15 @ Software termination signal (sent by kill by default)
.equ SIGTTOU, 22 @
.equ NBBOX, 16
.equ TAILLEBUFFER, 10
/*******************************************/
/* Structures */
/********************************************/
/* structure termios see doc linux*/
.struct 0
term_c_iflag: @ input modes
.struct term_c_iflag + 4
term_c_oflag: @ output modes
.struct term_c_oflag + 4
term_c_cflag: @ control modes
.struct term_c_cflag + 4
term_c_lflag: @ local modes
.struct term_c_lflag + 4
term_c_cc: @ special characters
.struct term_c_cc + 20 @ see length if necessary
term_fin:
/* structure sigaction see doc linux */
.struct 0
sa_handler:
.struct sa_handler + 4
sa_mask:
.struct sa_mask + 4
sa_flags:
.struct sa_flags + 4
sa_sigaction:
.struct sa_sigaction + 4
sa_fin:
/* structure poll see doc linux */
.struct 0
poll_fd: @ File Descriptor
.struct poll_fd + 4
poll_events: @ events mask
.struct poll_events + 4
poll_revents: @ events returned
.struct poll_revents + 4
poll_fin:
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .ascii " "
sMessValeur: .fill 11, 1, ' ' @ size => 11
szCarriageReturn: .asciz "\n"
szMessGameWin: .ascii "You win in "
sMessCounter: .fill 11, 1, ' ' @ size => 11
.asciz " move number !!!!\n"
szMessMoveError: .asciz "Huh... Impossible move !!!!\n"
szMessErreur: .asciz "Error detected.\n"
szMessSpaces: .asciz " "
iGraine: .int 123456
/*************************************************/
szMessErr: .ascii "Error code hexa : "
sHexa: .space 9,' '
.ascii " decimal : "
sDeci: .space 15,' '
.asciz "\n"
szClear: .byte 0x1B
.byte 'c' @ console clear
.byte 0
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
.align 4
iCodeError: .skip 4
ibox: .skip 4 * NBBOX @ game boxes
iEnd: .skip 4 @ 0 loop 1 = end loop
iTouche: .skip 4 @ value key pressed
stOldtio: .skip term_fin @ old terminal state
stCurtio: .skip term_fin @ current terminal state
stSigAction: .skip sa_fin @ area signal structure
stSigAction1: .skip sa_fin
stPoll1: .skip poll_fin @ area poll structure
stPoll2: .skip poll_fin
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
mov r0,#0
ldr r2,iAdribox
mov r9,#0 @ move counter
1: @ loop init boxs
add r1,r0,#1 @ box value
str r1,[r2,r0, lsl #2] @ store value
add r0,#1 @ increment counter
cmp r0,#NBBOX - 2 @ end ?
ble 1b
mov r10,#15 @ empty box location
ldr r0,iAdribox
bl shuffleGame
2: @ loop moves
ldr r0,iAdribox
bl displayGame
//ldr r0,iAdribox
//bl gameOK @ end game ?
//cmp r0,#1
//beq 50f
bl readKey @ read key
cmp r0,#-1
beq 100f @ error or control-c
mov r1,r0 @ key
ldr r0,iAdribox
bl keyMove
ldr r0,iAdribox
bl gameOK @ end game ?
cmp r0,#1
bne 2b @ no -> loop
50: @ win
mov r0,r9 @ move counter
ldr r1,iAdrsMessCounter
bl conversion10
ldr r0,iAdrszMessGameWin
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrsMessValeur: .int sMessValeur
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsMessResult: .int sMessResult
iAdribox: .int ibox
iAdrszMessGameWin: .int szMessGameWin
iAdrsMessCounter: .int sMessCounter
/******************************************************************/
/* key move */
/******************************************************************/
/* r0 contains boxs address */
/* r1 contains key value */
/* r9 move counter */
/* r10 contains location empty box */
keyMove:
push {r1-r8,lr} @ save registers
mov r8,r0
cmp r1,#0x42 @ down arrow
bne 1f
cmp r10,#4 @ if r10 < 4 error
blt 80f
sub r2,r10,#4 @ compute location
b 90f
1:
cmp r1,#0x41 @ high arrow
bne 2f
cmp r10,#11 @ if r10 > 11 error
bgt 80f
add r2,r10,#4 @ compute location
b 90f
2:
cmp r1,#0x43 @ right arrow
bne 3f
tst r10,#0b11 @ if r10 = 0,4,8,12 error
beq 80f
sub r2,r10,#1 @ compute location
b 90f
3:
cmp r1,#0x44 @ left arrow
bne 100f
and r3,r10,#0b11 @ error if r10 = 3 7 11 and 15
cmp r3,#3
beq 80f
add r2,r10,#1 @ compute location
b 90f
80: @ move error
ldr r0,iAdriCodeError
mov r1,#1
str r1,[r0]
b 100f
90: @ white box and move box inversion
ldr r3,[r8,r2,lsl #2]
str r3,[r8,r10,lsl #2]
mov r10,r2
mov r3,#0
str r3,[r8,r10,lsl #2]
add r9,#1 @ increment move counter
100:
pop {r1-r8,lr} @ restaur registers
bx lr @return
iAdriCodeError: .int iCodeError
/******************************************************************/
/* shuffle game */
/******************************************************************/
/* r0 contains boxs address */
shuffleGame:
push {r1-r6,lr} @ save registers
mov r1,r0
mov r0,#4
bl genereraleas
lsl r4,r0,#1
mov r0,r8
1:
mov r0,#14
bl genereraleas
add r6,r0,#1
mov r0,#14
bl genereraleas
add r5,r0,#1
ldr r2,[r1,r6,lsl #2]
ldr r3,[r1,r5,lsl #2]
str r2,[r1,r5,lsl #2]
str r3,[r1,r6,lsl #2]
subs r4,#1
bgt 1b
100:
pop {r1-r6,lr} @ restaur registers
bx lr @return
/******************************************************************/
/* game Ok ? */
/******************************************************************/
/* r0 contains boxs address */
gameOK:
push {r1-r8,lr} @ save registers
mov r8,r0
mov r2,#0
ldr r3,[r8,r2,lsl #2]
add r2,#1
1:
ldr r4,[r8,r2,lsl #2]
cmp r4,r3
movlt r0,#0 @ game mot Ok
blt 100f
mov r3,r4
add r2,#1
cmp r2,#NBBOX -2
ble 1b
mov r0,#1 @ game Ok
100:
pop {r1-r8,lr} @ restaur registers
bx lr @return
/******************************************************************/
/* display game */
/******************************************************************/
/* r0 contains boxs address */
displayGame:
push {r1-r5,lr} @ save registers
@ clear !
mov r4,r0
ldr r0,iAdrszClear
bl affichageMess
mov r2,#0
ldr r1,iAdrsMessValeur
1:
ldr r0,[r4,r2,lsl #2]
cmp r0,#0
ldreq r0,iSpaces @ store spaces
streq r0,[r1]
beq 2f
bl conversion10 @ call conversion decimal
mov r0,#0
strb r0,[r1,#3] @ zéro final
2:
ldr r0,iAdrsMessResult
bl affichageMess @ display message
add r0,r2,#1
tst r0,#0b11
bne 3f
ldr r0,iAdrszCarriageReturn
bl affichageMess @ display message
3:
add r2,#1
cmp r2,#NBBOX - 1
ble 1b
ldr r0,iAdrszCarriageReturn
bl affichageMess @ display line return
ldr r0,iAdriCodeError @ error detected ?
ldr r1,[r0]
cmp r1,#0
beq 100f
mov r1,#0 @ raz error code
str r1,[r0]
ldr r0,iAdrszMessMoveError @ display error message
bl affichageMess
100:
pop {r1-r5,lr} @ restaur registers
bx lr @return
iSpaces: .int 0x00202020 @ spaces
iAdrszClear: .int szClear
iAdrszMessMoveError: .int szMessMoveError
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registres
mov r2,#0 @ counter length
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call systeme
pop {r0,r1,r2,r7,lr} @ restaur des 2 registres */
bx lr @ return
/******************************************************************/
/* Converting a register to a decimal unsigned */
/******************************************************************/
/* r0 contains value and r1 address area */
/* r0 return size of result (no zero final in area) */
/* area size => 11 bytes */
.equ LGZONECAL, 10
conversion10:
push {r1-r4,lr} @ save registers
mov r3,r1
mov r2,#LGZONECAL
1: @ start loop
bl divisionpar10U @ unsigned r0 <- dividende. quotient ->r0 reste -> r1
add r1,#48 @ digit
strb r1,[r3,r2] @ store digit on area
cmp r0,#0 @ stop if quotient = 0
subne r2,#1 @ else previous position
bne 1b @ and loop
@ and move digit from left of area
mov r4,#0
2:
ldrb r1,[r3,r2]
strb r1,[r3,r4]
add r2,#1
add r4,#1
cmp r2,#LGZONECAL
ble 2b
@ and move spaces in end on area
mov r0,r4 @ result length
mov r1,#' ' @ space
3:
strb r1,[r3,r4] @ store space in area
add r4,#1 @ next position
cmp r4,#LGZONECAL
ble 3b @ loop if r4 <= area size
100:
pop {r1-r4,lr} @ restaur registres
bx lr @return
/***************************************************/
/* division par 10 unsigned */
/***************************************************/
/* r0 dividende */
/* r0 quotient */
/* r1 remainder */
divisionpar10U:
push {r2,r3,r4, lr}
mov r4,r0 @ save value
ldr r3,iMagicNumber @ r3 <- magic_number raspberry 1 2
umull r1, r2, r3, r0 @ r1<- Lower32Bits(r1*r0) r2<- Upper32Bits(r1*r0)
mov r0, r2, LSR #3 @ r2 <- r2 >> shift 3
add r2,r0,r0, lsl #2 @ r2 <- r0 * 5
sub r1,r4,r2, lsl #1 @ r1 <- r4 - (r2 * 2) = r4 - (r0 * 10)
pop {r2,r3,r4,lr}
bx lr @ leave function
iMagicNumber: .int 0xCCCCCCCD
/***************************************************/
/* Generation random number */
/***************************************************/
/* r0 contains limit */
genereraleas:
push {r1-r4,lr} @ save registers
ldr r4,iAdriGraine
ldr r2,[r4]
ldr r3,iNbDep1
mul r2,r3,r2
ldr r3,iNbDep1
add r2,r2,r3
str r2,[r4] @ maj de la graine pour l appel suivant
cmp r0,#0
beq 100f
mov r1,r0 @ divisor
mov r0,r2 @ dividende
bl division
mov r0,r3 @ résult = remainder
100: @ end function
pop {r1-r4,lr} @ restaur registers
bx lr @ return
/*****************************************************/
iAdriGraine: .int iGraine
iNbDep1: .int 0x343FD
iNbDep2: .int 0x269EC3
/***************************************************/
/* integer division unsigned */
/***************************************************/
division:
/* r0 contains dividend */
/* r1 contains divisor */
/* r2 returns quotient */
/* r3 returns remainder */
push {r4, lr}
mov r2, #0 @ init quotient
mov r3, #0 @ init remainder
mov r4, #32 @ init counter bits
b 2f
1: @ loop
movs r0, r0, LSL #1 @ r0 <- r0 << 1 updating cpsr (sets C if 31st bit of r0 was 1)
adc r3, r3, r3 @ r3 <- r3 + r3 + C. This is equivalent to r3 ? (r3 << 1) + C
cmp r3, r1 @ compute r3 - r1 and update cpsr
subhs r3, r3, r1 @ if r3 >= r1 (C=1) then r3 <- r3 - r1
adc r2, r2, r2 @ r2 <- r2 + r2 + C. This is equivalent to r2 <- (r2 << 1) + C
2:
subs r4, r4, #1 @ r4 <- r4 - 1
bpl 1b @ if r4 >= 0 (N=0) then loop
pop {r4, lr}
bx lr
/***************************************************/
/* read touch */
/***************************************************/
readKey:
push {r1-r7,lr}
mov r5,#0
/* read terminal state */
mov r0,#STDIN @ input console
mov r1,#TCGETS
ldr r2,iAdrstOldtio
mov r7, #IOCTL @ call system Linux
svc #0
cmp r0,#0 @ error ?
beq 1f
ldr r1,iAdrszMessErreur @ error message
bl displayError
mov r0,#-1
b 100f
1:
adr r0,sighandler @ adresse routine traitement signal
ldr r1,iAdrstSigAction @ adresse structure sigaction
str r0,[r1,#sa_handler] @ maj handler
mov r0,#SIGINT @ signal type
ldr r1,iAdrstSigAction
mov r2,#0 @ NULL
mov r7, #SIGACTION @ call system
svc #0
cmp r0,#0 @ error ?
bne 97f
mov r0,#SIGQUIT
ldr r1,iAdrstSigAction
mov r2,#0 @ NULL
mov r7, #SIGACTION @ call system
svc #0
cmp r0,#0 @ error ?
bne 97f
mov r0,#SIGTERM
ldr r1,iAdrstSigAction
mov r2,#0 @ NULL
mov r7, #SIGACTION @ appel systeme
svc #0
cmp r0,#0
bne 97f
@
adr r0,iSIG_IGN @ address signal ignore function
ldr r1,iAdrstSigAction1
str r0,[r1,#sa_handler]
mov r0,#SIGTTOU @invalidate other process signal
ldr r1,iAdrstSigAction1
mov r2,#0 @ NULL
mov r7,#SIGACTION @ call system
svc #0
cmp r0,#0
bne 97f
@
/* read terminal current state */
mov r0,#STDIN
mov r1,#TCGETS
ldr r2,iAdrstCurtio @ address current termio
mov r7,#IOCTL @ call systeme
svc #0
cmp r0,#0 @ error ?
bne 97f
mov r2,#ICANON | ECHO @ no key pressed echo on display
mvn r2,r2 @ and one key
ldr r1,iAdrstCurtio
ldr r3,[r1,#term_c_lflag]
and r3,r2 @ add flags
str r3,[r1,#term_c_lflag] @ and store
mov r0,#STDIN @ maj terminal current state
mov r1,#TCSETS
ldr r2,iAdrstCurtio
mov r7, #IOCTL @ call system
svc #0
cmp r0,#0
bne 97f
@
2: @ loop waiting key
ldr r0,iAdriEnd @ if signal ctrl-c -> end
ldr r0,[r0]
cmp r0,#0
movne r5,#-1
bne 98f
ldr r0,iAdrstPoll1 @ address structure poll
mov r1,#STDIN
str r1,[r0,#poll_fd] @ maj FD
mov r1,#POLLIN @ action code
str r1,[r0,#poll_events]
mov r1,#1 @ items number structure poll
mov r2,#0 @ timeout = 0
mov r7,#SYSPOLL @ call system POLL
svc #0
cmp r0,#0 @ key pressed ?
ble 2b @ no key pressed -> loop
@ read key
mov r0,#STDIN @ File Descriptor
ldr r1,iAdriTouche @ buffer address
mov r2,#TAILLEBUFFER @ buffer size
mov r7,#READ @ read key
svc #0
cmp r0,#0 @ error ?
bgt 98f
97: @ error detected
ldr r1,iAdrszMessErreur @ error message
bl displayError
mov r5,#-1
98: @ end then restaur begin state terminal
mov r0,#STDIN
mov r1,#TCSETS
ldr r2,iAdrstOldtio
mov r7,#IOCTL @ call system
svc #0
cmp r0,#0
beq 99f @ restaur ok
ldr r1,iAdrszMessErreur @ error message
bl displayError
mov r0,#-1
b 100f
99:
cmp r5,#0 @ error or control-c
ldreq r2,iAdriTouche @ key address
ldreqb r0,[r2,#2] @ return key byte
movne r0,r5 @ or error
100:
pop {r1-r7, lr}
bx lr
iSIG_IGN: .int 1
iAdriEnd: .int iEnd
iAdrstPoll1: .int stPoll1
iAdriTouche: .int iTouche
iAdrstOldtio: .int stOldtio
iAdrstCurtio: .int stCurtio
iAdrstSigAction: .int stSigAction
iAdrstSigAction1: .int stSigAction1
iAdrszMessErreur : .int szMessErreur
/******************************************************************/
/* traitement du signal */
/******************************************************************/
sighandler:
push {r0,r1}
ldr r0,iAdriEnd
mov r1,#1 @ maj zone end
str r1,[r0]
pop {r0,r1}
bx lr
/***************************************************/
/* display error message */
/***************************************************/
/* r0 contains error code r1 : message address */
displayError:
push {r0-r2,lr} @ save registers
mov r2,r0 @ save error code
mov r0,r1
bl affichageMess
mov r0,r2 @ error code
ldr r1,iAdrsHexa
bl conversion16 @ conversion hexa
mov r0,r2 @ error code
ldr r1,iAdrsDeci @ result address
bl conversion10 @ conversion decimale
ldr r0,iAdrszMessErr @ display error message
bl affichageMess
100:
pop {r0-r2,lr} @ restaur registers
bx lr @ return
iAdrszMessErr: .int szMessErr
iAdrsHexa: .int sHexa
iAdrsDeci: .int sDeci
/******************************************************************/
/* Converting a register to hexadecimal */
/******************************************************************/
/* r0 contains value and r1 address area */
conversion16:
push {r1-r4,lr} @ save registers
mov r2,#28 @ start bit position
mov r4,#0xF0000000 @ mask
mov r3,r0 @ save entry value
1: @ start loop
and r0,r3,r4 @value register and mask
lsr r0,r2 @ move right
cmp r0,#10 @ compare value
addlt r0,#48 @ <10 ->digit
addge r0,#55 @ >10 ->letter A-F
strb r0,[r1],#1 @ store digit on area and + 1 in area address
lsr r4,#4 @ shift mask 4 positions
subs r2,#4 @ counter bits - 4 <= zero ?
bge 1b @ no -> loop
100:
pop {r1-r4,lr} @ restaur registers
bx lr @return
|
http://rosettacode.org/wiki/2048 | 2048 | Task
Implement a 2D sliding block puzzle game where blocks with numbers are combined to add their values.
Rules of the game
The rules are that on each turn the player must choose a direction (up, down, left or right).
All tiles move as far as possible in that direction, some move more than others.
Two adjacent tiles (in that direction only) with matching numbers combine into one bearing the sum of those numbers.
A move is valid when at least one tile can be moved, if only by combination.
A new tile with the value of 2 is spawned at the end of each turn at a randomly chosen empty square (if there is one).
Adding a new tile on a blank space. Most of the time, a new 2 is to be added, and occasionally (10% of the time), a 4.
To win, the player must create a tile with the number 2048.
The player loses if no valid moves are possible.
The name comes from the popular open-source implementation of this game mechanic, 2048.
Requirements
"Non-greedy" movement.
The tiles that were created by combining other tiles should not be combined again during the same turn (move).
That is to say, that moving the tile row of:
[2][2][2][2]
to the right should result in:
......[4][4]
and not:
.........[8]
"Move direction priority".
If more than one variant of combining is possible, move direction shall indicate which combination will take effect.
For example, moving the tile row of:
...[2][2][2]
to the right should result in:
......[2][4]
and not:
......[4][2]
Check for valid moves. The player shouldn't be able to skip their turn by trying a move that doesn't change the board.
Check for a win condition.
Check for a lose condition.
| #C.23 | C# | using System;
namespace g2048_csharp
{
internal class Tile
{
public Tile()
{
Value = 0;
IsBlocked = false;
}
public int Value { get; set; }
public bool IsBlocked { get; set; }
}
internal enum MoveDirection
{
Up,
Down,
Left,
Right
}
internal class G2048
{
public G2048()
{
_isDone = false;
_isWon = false;
_isMoved = true;
_score = 0;
InitializeBoard();
}
private void InitializeBoard()
{
for (int y = 0; y < 4; y++)
{
for (int x = 0; x < 4; x++)
{
_board[x, y] = new Tile();
}
}
}
private bool _isDone;
private bool _isWon;
private bool _isMoved;
private int _score;
private readonly Tile[,] _board = new Tile[4, 4];
private readonly Random _rand = new Random();
public void Loop()
{
AddTile();
while (true)
{
if (_isMoved)
{
AddTile();
}
DrawBoard();
if (_isDone)
{
break;
}
WaitKey();
}
string endMessage = _isWon ? "You've made it!" : "Game Over!";
Console.WriteLine(endMessage);
}
private void DrawBoard()
{
Console.Clear();
Console.WriteLine("Score: " + _score + "\n");
for (int y = 0; y < 4; y++)
{
Console.WriteLine("+------+------+------+------+");
Console.Write("| ");
for (int x = 0; x < 4; x++)
{
if (_board[x, y].Value == 0)
{
const string empty = " ";
Console.Write(empty.PadRight(4));
}
else
{
Console.Write(_board[x, y].Value.ToString().PadRight(4));
}
Console.Write(" | ");
}
Console.WriteLine();
}
Console.WriteLine("+------+------+------+------+\n\n");
}
private void WaitKey()
{
_isMoved = false;
Console.WriteLine("(W) Up (S) Down (A) Left (D) Right");
char input;
char.TryParse(Console.ReadKey().Key.ToString(), out input);
switch (input)
{
case 'W':
Move(MoveDirection.Up);
break;
case 'A':
Move(MoveDirection.Left);
break;
case 'S':
Move(MoveDirection.Down);
break;
case 'D':
Move(MoveDirection.Right);
break;
}
for (int y = 0; y < 4; y++)
{
for (int x = 0; x < 4; x++)
{
_board[x, y].IsBlocked = false;
}
}
}
private void AddTile()
{
for (int y = 0; y < 4; y++)
{
for (int x = 0; x < 4; x++)
{
if (_board[x, y].Value != 0) continue;
int a, b;
do
{
a = _rand.Next(0, 4);
b = _rand.Next(0, 4);
} while (_board[a, b].Value != 0);
double r = _rand.NextDouble();
_board[a, b].Value = r > 0.89f ? 4 : 2;
if (CanMove())
{
return;
}
}
}
_isDone = true;
}
private bool CanMove()
{
for (int y = 0; y < 4; y++)
{
for (int x = 0; x < 4; x++)
{
if (_board[x, y].Value == 0)
{
return true;
}
}
}
for (int y = 0; y < 4; y++)
{
for (int x = 0; x < 4; x++)
{
if (TestAdd(x + 1, y, _board[x, y].Value)
|| TestAdd(x - 1, y, _board[x, y].Value)
|| TestAdd(x, y + 1, _board[x, y].Value)
|| TestAdd(x, y - 1, _board[x, y].Value))
{
return true;
}
}
}
return false;
}
private bool TestAdd(int x, int y, int value)
{
if (x < 0 || x > 3 || y < 0 || y > 3)
{
return false;
}
return _board[x, y].Value == value;
}
private void MoveVertically(int x, int y, int d)
{
if (_board[x, y + d].Value != 0
&& _board[x, y + d].Value == _board[x, y].Value
&& !_board[x, y].IsBlocked
&& !_board[x, y + d].IsBlocked)
{
_board[x, y].Value = 0;
_board[x, y + d].Value *= 2;
_score += _board[x, y + d].Value;
_board[x, y + d].IsBlocked = true;
_isMoved = true;
}
else if (_board[x, y + d].Value == 0
&& _board[x, y].Value != 0)
{
_board[x, y + d].Value = _board[x, y].Value;
_board[x, y].Value = 0;
_isMoved = true;
}
if (d > 0)
{
if (y + d < 3)
{
MoveVertically(x, y + d, 1);
}
}
else
{
if (y + d > 0)
{
MoveVertically(x, y + d, -1);
}
}
}
private void MoveHorizontally(int x, int y, int d)
{
if (_board[x + d, y].Value != 0
&& _board[x + d, y].Value == _board[x, y].Value
&& !_board[x + d, y].IsBlocked
&& !_board[x, y].IsBlocked)
{
_board[x, y].Value = 0;
_board[x + d, y].Value *= 2;
_score += _board[x + d, y].Value;
_board[x + d, y].IsBlocked = true;
_isMoved = true;
}
else if (_board[x + d, y].Value == 0
&& _board[x, y].Value != 0)
{
_board[x + d, y].Value = _board[x, y].Value;
_board[x, y].Value = 0;
_isMoved = true;
}
if (d > 0)
{
if (x + d < 3)
{
MoveHorizontally(x + d, y, 1);
}
}
else
{
if (x + d > 0)
{
MoveHorizontally(x + d, y, -1);
}
}
}
private void Move(MoveDirection direction)
{
switch (direction)
{
case MoveDirection.Up:
for (int x = 0; x < 4; x++)
{
int y = 1;
while (y < 4)
{
if (_board[x, y].Value != 0)
{
MoveVertically(x, y, -1);
}
y++;
}
}
break;
case MoveDirection.Down:
for (int x = 0; x < 4; x++)
{
int y = 2;
while (y >= 0)
{
if (_board[x, y].Value != 0)
{
MoveVertically(x, y, 1);
}
y--;
}
}
break;
case MoveDirection.Left:
for (int y = 0; y < 4; y++)
{
int x = 1;
while (x < 4)
{
if (_board[x, y].Value != 0)
{
MoveHorizontally(x, y, -1);
}
x++;
}
}
break;
case MoveDirection.Right:
for (int y = 0; y < 4; y++)
{
int x = 2;
while (x >= 0)
{
if (_board[x, y].Value != 0)
{
MoveHorizontally(x, y, 1);
}
x--;
}
}
break;
}
}
}
internal static class Program
{
public static void Main(string[] args)
{
RunGame();
}
private static void RunGame()
{
G2048 game = new G2048();
game.Loop();
CheckRestart();
}
private static void CheckRestart()
{
Console.WriteLine("(N) New game (P) Exit");
while (true)
{
char input;
char.TryParse(Console.ReadKey().Key.ToString(), out input);
switch (input)
{
case 'N':
RunGame();
break;
case 'P':
return;
default:
ClearLastLine();
break;
}
}
}
private static void ClearLastLine()
{
Console.SetCursorPosition(0, Console.CursorTop);
Console.Write(new string(' ', Console.BufferWidth));
Console.SetCursorPosition(0, Console.CursorTop - 1);
}
}
}
|
http://rosettacode.org/wiki/4-rings_or_4-squares_puzzle | 4-rings or 4-squares puzzle | 4-rings or 4-squares puzzle
You are encouraged to solve this task according to the task description, using any language you may know.
Task
Replace a, b, c, d, e, f, and
g with the decimal
digits LOW ───► HIGH
such that the sum of the letters inside of each of the four large squares add up to
the same sum.
╔══════════════╗ ╔══════════════╗
║ ║ ║ ║
║ a ║ ║ e ║
║ ║ ║ ║
║ ┌───╫──────╫───┐ ┌───╫─────────┐
║ │ ║ ║ │ │ ║ │
║ │ b ║ ║ d │ │ f ║ │
║ │ ║ ║ │ │ ║ │
║ │ ║ ║ │ │ ║ │
╚══════════╪═══╝ ╚═══╪══════╪═══╝ │
│ c │ │ g │
│ │ │ │
│ │ │ │
└──────────────┘ └─────────────┘
Show all output here.
Show all solutions for each letter being unique with
LOW=1 HIGH=7
Show all solutions for each letter being unique with
LOW=3 HIGH=9
Show only the number of solutions when each letter can be non-unique
LOW=0 HIGH=9
Related task
Solve the no connection puzzle
| #Ruby | Ruby | def four_squares(low, high, unique=true, show=unique)
f = -> (a,b,c,d,e,f,g) {[a+b, b+c+d, d+e+f, f+g].uniq.size == 1}
if unique
uniq = "unique"
solutions = [*low..high].permutation(7).select{|ary| f.call(*ary)}
else
uniq = "non-unique"
solutions = [*low..high].repeated_permutation(7).select{|ary| f.call(*ary)}
end
if show
puts " " + [*"a".."g"].join(" ")
solutions.each{|ary| p ary}
end
puts "#{solutions.size} #{uniq} solutions in #{low} to #{high}"
puts
end
[[1,7], [3,9]].each do |low, high|
four_squares(low, high)
end
four_squares(0, 9, false) |
http://rosettacode.org/wiki/15_puzzle_solver | 15 puzzle solver | Your task is to write a program that finds a solution in the fewest moves possible single moves to a random Fifteen Puzzle Game.
For this task you will be using the following puzzle:
15 14 1 6
9 11 4 12
0 10 7 3
13 8 5 2
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 0
The output must show the moves' directions, like so: left, left, left, down, right... and so on.
There are two solutions, of fifty-two moves:
rrrulddluuuldrurdddrullulurrrddldluurddlulurruldrdrd
rrruldluuldrurdddluulurrrdlddruldluurddlulurruldrrdd
see: Pretty Print of Optimal Solution
Finding either one, or both is an acceptable result.
Extra credit.
Solve the following problem:
0 12 9 13
15 11 10 14
3 7 2 5
4 8 6 1
Related Task
15 puzzle game
A* search algorithm
| #Lua | Lua |
#!/usr/bin/lua
--[[
Solve 3X3 sliding tile puzzle using Astar on Lua. Requires 3mb and
millions of recursions.
by RMM 2020-may-1
]]--
local SOLUTION_LIMIT, MAX_F_VALUE = 100,100
local NR, NC, RCSIZE = 4,4,4*4
local Up, Down, Right, Left = 'u','d','r','l'
local G_cols = {} -- goal columns
local G_rows = {} -- goal rows
local C_cols = {} -- current cols
local C_rows = {} -- current rows
local Goal = {}
local Tiles = {} -- the puzzle
local Solution = {} -- final path is instance of desc
local desc = {} -- descending path
desc[0] = 0 -- override Lua default "1" index
-- @brief create C compatible array for Lua
local function Amake( list )
array = {}
for i=0, #list do
array[i] = list[i+1] -- simulate "C" array in Lua
end
return array
end
G_cols= Amake({0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, } )
G_rows= Amake({0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, } )
C_cols= Amake({0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, } )
C_rows= Amake({0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, } )
Tiles = Amake({ 15,14,1,6, 9,11,4,12, 0,10,7,3, 13,8,5,2,} )
Goal = Amake({1,2,3,4, 5,6,7,8, 9,10,11,12, 13,14,15,0,} )
local m1 = {recursions=0, found=0, threshold=0, times=0, steps=0,}
-- ---------------------------------------------------------------
-- return 1D array index given 2D row,column
local function rcidx( row, col )
return (row * NR + col)
end
-- @brief recursive search
-- @return f_score
local function search( depth, x_row, x_col, h_score)
local move, go_back_move, last_move_by_current
local f_score, ix, min, temp, hscore2, idx1
local N_minus_one = NR - 1;
local rc1 = {row=0,col=0}
local rc2 = {row=0,col=0}
local gtmp = {row=0,col=0}
f_score = depth + h_score;
if f_score > m1.threshold then return f_score end
if h_score == 0 then do
m1.found = 1
Solution = table.concat(desc)
return f_score end end
m1.recursions = m1.recursions+1
m1.times = m1.times + 1
if m1.times > 200000 then do
print("Recursions ",m1.recursions)
m1.times = 0
end end
min = 999999
last_move_by_current = desc[depth];
rc1.row = x_row;
rc1.col = x_col;
for ix = 0,3 do
if ix==0 then do
move = Up;
go_back_move = Down;
rc2.row = x_row - 1;
rc2.col = x_col;
end
elseif ix==1 then do
move = Down;
go_back_move = Up;
rc2.row = x_row + 1;
rc2.col = x_col;
end
elseif ix==2 then do
move = Left;
go_back_move = Right;
rc2.row = x_row;
rc2.col = x_col - 1;
end
elseif ix==3 then do
move = Right;
go_back_move = Left;
rc2.row = x_row;
rc2.col = x_col + 1;
end end
if move==Up and x_row==0 then goto next end
if move==Down and x_row==N_minus_one then goto next end
if move==Left and x_col==0 then goto next end
if move==Right and x_col==N_minus_one then goto next end
if last_move_by_current==go_back_move then goto next end
hscore2 = h_score
idx1 = Tiles[rcidx(rc2.row,rc2.col)]
gtmp.row = G_rows[idx1]
gtmp.col = G_cols[idx1]
local h_adj=0
if go_back_move==Up then do
if gtmp.row < C_rows[idx1] then
h_adj = -1 else h_adj = 1 end end
end
if go_back_move==Down then do
if gtmp.row > C_rows[idx1] then
h_adj = -1 else h_adj = 1 end end
end
if go_back_move==Left then do
if gtmp.col < C_cols[idx1] then
h_adj = -1 else h_adj = 1 end end
end
if go_back_move==Right then do
if gtmp.col > C_cols[idx1] then
h_adj = -1 else h_adj = 1 end end
end
hscore2 = hscore2 + h_adj
C_rows[0] = rc2.row;
C_cols[0] = rc2.col;
C_rows[idx1] = rc1.row;
C_cols[idx1] = rc1.col;
Tiles[rcidx(rc1.row,rc1.col)] = idx1;
Tiles[rcidx(rc2.row,rc2.col)] = 0;
desc[depth+1] = move
desc[depth+2] = '\0'
temp = search(depth+1, rc2.row, rc2.col, hscore2); -- descend
-- regress
Tiles[rcidx(rc1.row,rc1.col)] = 0
Tiles[rcidx(rc2.row,rc2.col)] = idx1
desc[depth+1] = '\0'
C_rows[0] = rc1.row;
C_cols[0] = rc1.col;
C_rows[idx1] = rc2.row;
C_cols[idx1] = rc2.col;
if m1.found == 1 then return temp end
if temp < min then min = temp end
::next:: -- Lua does not have "continue;" so uses goto
end -- end for
m1.found = 0;
-- return the minimum f_score greater than m1.threshold
return min;
end
-- @brief Run solver using A-star algorithm
-- @param Tiles .. 3X3 sliding tile puzzle
local function solve(Tiles)
local temp, i,j
local x_row, x_col, h_score = 0,0,0
m1.found = 0;
for i=0,(NR-1) do
for j=0, (NC-1) do
G_rows[ Goal[rcidx(i,j)] ] = i;
G_cols[ Goal[rcidx(i,j)] ] = j;
C_rows[ Tiles[rcidx(i,j)] ] = i;
C_cols[ Tiles[rcidx(i,j)] ] = j;
end
end
for i=0,(NR-1) do
for j=0, (NC-1) do
if Tiles[rcidx(i,j)] == 0 then do
x_row = i;
x_col = j;
break;
end
end
end
end
desc[0] = '$'
desc[1] = '\0'
h_score = 0; -- Manhattan/Taxicab heuristic
for i = 1,(RCSIZE-1) do
h_score = h_score + (math.abs(C_rows[i] - G_rows[i]) +
math.abs(C_cols[i] - G_cols[i]))
end
m1.threshold = h_score
print("solve -> search")
while true do
temp = search( 0, x_row, x_col, h_score);
if m1.found == 1 then do
print("Gound solution of length",#Solution-1)
print(Solution)
break;
end end
if temp > MAX_F_VALUE then do
print("Maximum f value reached! terminating! \n");
break; end
end
m1.threshold = temp;
end -- while
return 0
end
-- show sliding tile puzzle rows and columns
local function print_tiles( pt)
local i,j,num
for i=0,(NR-1) do
for j=0, (NC-1) do
num = pt[rcidx(i,j)]
io.write(string.format("%02d ", num))
end
print("")
end
print("")
end
-- main(void) {
print("Solve sliding 15 tile puzzle");
m1.recursions = 0
m1.times=0
print_tiles(Tiles);
print_tiles(Goal)
solve(Tiles);
|
http://rosettacode.org/wiki/99_bottles_of_beer | 99 bottles of beer | Task
Display the complete lyrics for the song: 99 Bottles of Beer on the Wall.
The beer song
The lyrics follow this form:
99 bottles of beer on the wall
99 bottles of beer
Take one down, pass it around
98 bottles of beer on the wall
98 bottles of beer on the wall
98 bottles of beer
Take one down, pass it around
97 bottles of beer on the wall
... and so on, until reaching 0 (zero).
Grammatical support for 1 bottle of beer is optional.
As with any puzzle, try to do it in as creative/concise/comical a way
as possible (simple, obvious solutions allowed, too).
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
See also
http://99-bottles-of-beer.net/
Category:99_Bottles_of_Beer
Category:Programming language families
Wikipedia 99 bottles of beer
| #Arbre | Arbre |
bottle(x):
template: '
$x bottles of beer on the wall.
$x bottles of beer.
Take one down and pass it around,
$y bottles of beer on the wall.
'
if x==0
template~{x: 'No more', y: 'No more'}
else
if x==1
template~{x: x, y: 'No more'}
else
template~{x: x, y: x-1}
bottles(n):
for x in [n..0]
bottle(x)
99bottles():
bottles(99) -> io
|
http://rosettacode.org/wiki/24_game | 24 game | The 24 Game tests one's mental arithmetic.
Task
Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
The goal is for the player to enter an expression that (numerically) evaluates to 24.
Only the following operators/functions are allowed: multiplication, division, addition, subtraction
Division should use floating point or rational arithmetic, etc, to preserve remainders.
Brackets are allowed, if using an infix expression evaluator.
Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
The order of the digits when given does not have to be preserved.
Notes
The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
The task is not for the program to generate the expression, or test whether an expression is even possible.
Related tasks
24 game/Solve
Reference
The 24 Game on h2g2.
| #Factor | Factor | USING:
combinators.short-circuit
continuations
eval
formatting
fry
kernel
io
math math.ranges
prettyprint
random
sequences
sets ;
IN: 24game
: choose4 ( -- seq )
4 [ 9 [1,b] random ] replicate ;
: step ( numbers -- ? )
readln
[
parse-string
{
! Is only allowed tokens used?
[ swap { + - / * } append subset? ]
! Digit count in expression should be equal to the given numbers.
[ [ number? ] count swap length = ]
! Of course it must evaluate to 24
[ nip call( -- x ) 24 = ]
} 2&&
[ f "You got it!" ]
[ t "Expression isnt valid, or doesnt evaluate to 24." ]
if
]
[ 3drop f "Could not parse that." ]
recover print flush ;
: main ( -- )
choose4
[ "Your numbers are %[%s, %], make an expression\n" printf flush ]
[ '[ _ step ] loop ]
bi ;
|
http://rosettacode.org/wiki/A%2BB | A+B | A+B ─── a classic problem in programming contests, it's given so contestants can gain familiarity with the online judging system being used.
Task
Given two integers, A and B.
Their sum needs to be calculated.
Input data
Two integers are written in the input stream, separated by space(s):
(
−
1000
≤
A
,
B
≤
+
1000
)
{\displaystyle (-1000\leq A,B\leq +1000)}
Output data
The required output is one integer: the sum of A and B.
Example
input
output
2 2
4
3 2
5
| #Component_Pascal | Component Pascal |
MODULE AB;
IMPORT StdLog, DevCommanders,TextMappers;
PROCEDURE DoAB(x,y: INTEGER);
BEGIN
StdLog.Int(x);StdLog.Int(y);StdLog.Int(x + y);StdLog.Ln;
END DoAB;
PROCEDURE Go*;
VAR
params: DevCommanders.Par;
s: TextMappers.Scanner;
p : ARRAY 2 OF INTEGER;
current: INTEGER;
BEGIN
current := 0;
params := DevCommanders.par;
s.ConnectTo(params.text);
s.SetPos(params.beg);
s.Scan;
WHILE(~s.rider.eot) DO
IF (s.type = TextMappers.int) THEN
p[current] := s.int; INC(current);
END;
s.Scan;
END;
IF current = 2 THEN DoAB(p[0],p[1]) END;
END Go;
END AB.
|
Subsets and Splits