Department numbers: Difference between revisions

=={{header|11l}}==

{{trans|C}}

print(‘----------------------------------’)

 

L(fire) 1..7

I police!=sanitation & sanitation!=fire & fire!=police & police+fire+sanitation==12

{{Output}}

<pre>

 

=={{header|8080 Assembly}}==

lxi h,obuf ; HL = output buffer

mvi b,2 ; B = police

ret

ohdr: db 'P S F',13,10

 

{{out}}

=={{header|8086 Assembly}}==

 

bits 16

org 100h

section .data

ohdr: db 'P S F',13,10 ; Header

 

{{out}}

 

=={{header|Action!}}==

BYTE p,s,f

 

OD

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Department_numbers.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

 

procedure Department_Numbers is

end loop;

end loop;

 

{{out}}

 

=={{header|Aime}}==

 

p = 0;

}

}

 

=={{header|ALGOL 68}}==

As noted in the Fortran sample, once the police and sanitation departments are posited, the fire department value is fixed

# show possible department number allocations for police, sanitation and fire departments #

# the police department number must be even, all department numbers in the range 1 .. 7 #

OD

OD

{{out}}

<pre>

=={{header|ALGOL W}}==

{{Trans|ALGOL 68}}

% show possible department number allocations for police, sanitation and fire departments %

% the police department number must be even, all department numbers in the range 1 .. 7 %

end for_sanitation

end for_police

{{out}}

<pre>

=={{header|APL}}==

 

 

This prints each triplet of numbers from 1 to 7 for which:

Briefly, composing a solution from generic functions:

 

script

on |λ|(x)

on unlines(xs)

intercalate(linefeed, xs)

{{Out}}

<pre>237

{{Trans|JavaScript}}

{{Trans|Haskell}}

 

-- options :: Int -> Int -> Int -> [(Int, Int, Int)]

on unlines(xs)

intercalate(linefeed, xs)

{{Out}}

<pre>(Police, Sanitation, Fire)

=={{header|Arturo}}==

 

loop 1..7 'y [

loop 1..7 'z [

]

]

 

{{out}}

 

=={{header|Asymptote}}==

for(int police = 2; police < 6; police += 2) {

}

}

 

=={{header|AutoHotkey}}==

res := IsObject(res) ? res : [], dup := IsObject(dup) ? dup : []

if (n > j)

Sort, res, D`n

return StrReplace(res, "`n", Delim)

for k, v in perm(elements, n)

if (SubStr(v, 1, 1) + SubStr(v, 2, 1) + SubStr(v, 3, 1) = 12) && (SubStr(v, 1, 1) / 2 = Floor(SubStr(v, 1, 1)/2))

 

MsgBox, 262144, , % res4

Outputs:<pre>237

246

 

=={{header|AWK}}==

# syntax: GAWK -f DEPARTMENT_NUMBERS.AWK

BEGIN {

return(stmt1 stmt2 stmt3)

}

{{out}}

<pre>

 

=={{header|BCPL}}==

 

let start() be

for f=1 to 7

if p~=s & s~=f & p~=f & p+s+f=12 then

{{out}}

<pre>2 3 7

The [[#Sinclair_ZX81_BASIC|Sinclair ZX81 BASIC]] solution works without any changes.

==={{header|BASIC256}}===

 

for police = 2 to 7 step 2

end if

next fire

{{out}}

<pre>--police-- --sanitation-- --fire--

 

==={{header|Run BASIC}}===

 

for police = 2 to 7 step 2

[cont]

next fire

 

==={{header|PureBasic}}===

PrintN("--police-- --sanitation-- --fire--")

 

 

Input()

{{out}}

<pre>Same as BASIC256 entry.</pre>

 

==={{header|Yabasic}}===

 

for police = 2 to 7 step 2

if sanitation >= 1 and sanitation <= 7 print police using "######", fire using "############", sanitation using "###########"

next fire

{{out}}

<pre>Same as BASIC256 entry.</pre>

 

==={{header|IS-BASIC}}===

110 FOR P=2 TO 7 STEP 2

120 FOR S=1 TO 7

141 END IF

150 NEXT

 

==={{header|Minimal BASIC}}===

{{trans|Sinclair ZX81 BASIC}}

10 REM Department numbers

20 PRINT "POLICE SANITATION FIRE"

100 NEXT P

110 END

 

==={{header|Sinclair ZX81 BASIC}}===

Works with 1k of RAM. This program ought not to need more than minimal changes to be compatible with any old-style BASIC dialect.

20 FOR P=2 TO 7 STEP 2

30 FOR S=1 TO 7

60 IF F>0 AND F<=7 AND F<>S AND F<>P THEN PRINT " ";P;" ";S;" ";F

70 NEXT S

{{out}}

<pre>POLICE SANITATION FIRE

==={{header|BBC BASIC}}===

{{trans|ALGOL 68}}

max_dept_num% = 7

dept_sum% = 12

NEXT

NEXT

{{out}}

<pre>police sanitation fire

 

==={{header|QBasic}}===

 

FOR police = 2 TO 7 STEP 2

cont:

NEXT fire

 

==={{header|XBasic}}===

{{works with|Windows XBasic}}

 

DECLARE FUNCTION Entry ()

NEXT police

END FUNCTION

 

=={{header|C}}==

Weird that such a simple task was still not implemented in C, would be great to see some really creative ( obfuscated ) solutions for this one.

#include<stdio.h>

 

return 0;

}

Output:

<pre>

 

=={{header|C sharp|C#}}==

public class Program

{

}

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <iostream>

#include <iomanip>

}

return 0;

{{out}}

<pre>

 

=={{header|Clojure}}==

(for [police n

sanitation n

:when (even? police)

:when (= 12 (+ police sanitation fire))]

{{Out}}

<pre>

 

=={{header|CLU}}==

po: stream := stream$primary_output()

end

end

{{out}}

<pre>P S F

 

=={{header|COBOL}}==

PROGRAM-ID. DEPARTMENT-NUMBERS.

 

AND SANITATION IS NOT EQUAL TO FIRE

AND TOTAL IS EQUAL TO 12,

{{out}}

<pre>POLICE SANITATION FIRE

 

=={{header|Cowgol}}==

 

typedef Dpt is int(1, 7);

end loop;

pol := pol + 2;

 

{{out}}

 

{{Trans|C++}}

import std.stdio, std.range;

 

}

}

Output:

<pre>

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Department_numbers;

 

writeln(#10, count, ' valid combinations');

readln;

 

=={{header|Draco}}==

byte police, sanitation, fire;

 

od

od

{{out}}

<pre>Police Sanitation Fire

 

=={{header|Elixir}}==

IO.puts("P - F - S")

for p <- [2,4,6],

|> Enum.each(&IO.puts/1)

 

P - F - S

2 - 3 - 7

6 - 4 - 2

6 - 5 - 1

 

=={{header|Excel}}==

 

{{Works with|Office 365 betas 2021}}

=validRows(

LAMBDA(ab,

)

)

 

and also assuming the following generic bindings in the Name Manager for the WorkBook:

 

=LAMBDA(xs,

LAMBDA(ys,

)

)

 

{{Out}}

 

=={{header|F_Sharp|F#}}==

// A function to generate department numbers. Nigel Galloway: May 2nd., 2018

type dNum = {Police:int; Fire:int; Sanitation:int}

let fN n=n.Police%2=0&&n.Police+n.Fire+n.Sanitation=12&&n.Police<>n.Fire&&n.Police<>n.Sanitation&&n.Fire<>n.Sanitation

List.init (7*7*7) (fun n->{Police=n%7+1;Fire=(n/7)%7+1;Sanitation=(n/49)+1})|>List.filter fN|>List.iter(printfn "%A")

{{out}}

<pre>

 

=={{header|Factor}}==

sequences sets ;

IN: rosetta-code.department-numbers

 

"{ Police, Sanitation, Fire }" print nl

{{out}}

<pre>

</pre>

=={{header|Fermat}}==

!!'------|----------|----';

for p = 2 to 6 by 2 do

for f = 1 to 7 do

if p+f+s=12 and f<>p and f<>s and s<>p then !!(' ',p,' ',s,' ',f);

{{out}}<pre>

Police Sanitation Fire

 

=={{header|FOCAL}}==

01.20 Q

 

02.40 I (P+S+G-12)2.6,2.5,2.6

02.50 T %1,P,S,G,!

{{out}}

<pre>= 2= 3= 7

 

=={{header|Forth}}==

: fire ( pol san fir -- )

2dup = if 2drop drop exit then

\ tries to assign numbers with police = 2, 4, or 6

: departments cr \ leave input line

 

{{out}}

Since the modernisers of Fortran made a point of specifying that it does not specify the manner of evaluation of compound boolean expressions, specifically, that there is to be no reliance on [[Short-circuit_evaluation]], both parts of the compound expression of the line labelled 5 "may" be evaluated even though the first may have determined the result. Prior to the introduction of LOGICAL variables with F66, one employed integer arithmetic as is demonstrated in the arithmetic-IF test of the line labelled 6. On the B6700, this usage ran faster than the corresponding boolean expression - possibly because there was no test for short-circuiting the expression when the first part of a multiply was zero...

 

1 PP:DO P = 2,7,2 !The police demand an even number. They're special and use violence.

2 SS:DO S = 1,7 !The sanitation department accepts any value.

8 END DO SS !Next S

9 END DO PP !Next P.

Output:

<pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>police fire sanitation

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=cdfeadc26aaeb0e23f4523626b6fe7c9 Click this link to run this code]'''

Dim siC0, siC1, siC2 As Short

Dim sOut As New String[]

Next

 

Output:

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

}

fmt.Printf("\n%d valid combinations\n", count)

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

println("Police Sanitation Fire")

println("$count valid combinations")

}

{{out}}

<pre>Police Sanitation Fire

 

=={{header|GW-BASIC}}==

20 PRINT "------|----------|----"

30 FOR P = 2 TO 7 STEP 2

90 NEXT F

100 NEXT S

 

=={{header|Haskell}}==

Bare minimum:

main =

mapM_ print $

case y /= z && 1 <= z && z <= 7 of

True -> [(x, y, z)]

or, resugaring this into list comprehension format:

main =

mapM_

, y <- [1 .. 7]

, z <- [12 - (x + y)]

Do notation:

main =

mapM_ print $

if y /= z && 1 <= z && z <= 7

then [(x, y, z)]

Unadorned brute force – more than enough at this small scale:

 

main :: IO ()

\z ->

[ (x, y, z)

{{Out}}

<pre>(2,3,7)

 

Or, more generally:

 

options :: Int -> Int -> Int -> [(Int, Int, Int)]

[ "\nNumber of options: ",

show (length xs)

 

Reaching again for a little more syntactic sugar, the options function above could also be re-written either as a list comprehension,

options lo hi total =

let ds = [lo .. hi]

, y <- filter (/= x) ds

, let z = total - (x + y)

 

or in Do notation:

 

options :: Int -> Int -> Int -> [(Int, Int, Int)]

let z = total - (x + y)

guard $ y /= z && lo <= z && z <= hi

{{Out}}

<pre>(Police, Sanitation, Fire)

=={{header|J}}==

'''Solution:'''

permfrom=: ,/@(perm@[ {"_ 1 comb) NB. get permutations of length x from y possible items

 

Validnums=: >: i.7 NB. valid Department numbers

 

'''Example usage:'''

4 1 7

4 7 1

6 4 2

4 3 5

 

===Alternate approach===

 

4 1 7

6 1 5

2 3 7

2 4 6

 

Note that we are only showing the distinct valid [[combinations]] here, not all valid [[permutations]] of those combinations.

=={{header|Java}}==

{{trans|Kotlin}}

public static void main(String[] args) {

System.out.println("Police Sanitation Fire");

System.out.printf("\n%d valid combinations", count);

}

{{out}}

<pre>Police Sanitation Fire

===ES5===

Briefly:

'use strict';

 

.map(JSON.stringify)

.join('\n');

{{Out}}

<pre>(Police, Sanitation, Fire)

Or, more generally:

{{Trans|Haskell}}

'use strict';

 

return '(Police, Sanitation, Fire)\n\n' +

unlines(map(show, xs)) + '\n\nNumber of options: ' + length(xs);

{{Out}}

<pre>(Police, Sanitation, Fire)

===ES6===

Briefly:

"use strict";

 

 

return `${label}\n${solutions}`;

{{Out}}

<pre>(Police, Sanitation, Fire)

Or, more generally, by composition of generic functions:

{{Trans|Haskell}}

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>(Police, Sanitation, Fire)

 

'''Nested for-loop'''

(fire != police) and (fire != sanitation) and (police != sanitation)

and (fire + police + sanitation == 12)

| range(1;8) as $sanitation

| select( check($fire; $police; $sanitation) )

 

'''In Brief'''

| select( .fire != .police and .fire != .sanitation and .police != .sanitation

and .fire + .police + .sanitation == 12

 

'''combinations'''

[range(1;8)]

| combinations(3)

| select( add == 12 and .[1] % 2 == 0)

 

=={{header|Julia}}==

 

function findsolution(rng=1:7)

 

printsolutions(findsolution())

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

}

println("\n$count valid combinations")

 

{{out}}

 

=={{header|Lua}}==

print( "Fire", "Police", "Sanitation" )

sol = 0

end

print( string.format( "\n%d solutions found", sol ) )

{{out}}

<pre>

 

=={{header|MAD}}==

PRINT COMMENT $ POLICE SANITATION FIRE$

THROUGH LOOP, FOR P=2, 2, P.G.7

LOOP CONTINUE

VECTOR VALUES OCC = $I6,S2,I10,S2,I4*$

{{out}}

<pre>POLICE SANITATION FIRE

 

=={{header|Maple}}==

exclusive_numbers := proc(i, j, k)

if (i = j) or (i = k) or (j = k) then

 

department_numbers();

{{out|Output}}

<pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>{{2, 3, 7}, {2, 4, 6}, {2, 6, 4}, {2, 7, 3}, {4, 1, 7}, {4, 2, 6}, {4, 3, 5}, {4, 5, 3},

 

=={{header|Modula-2}}==

FROM Conversions IMPORT IntToStr;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar;

 

=={{header|Mercury}}==

:- interface.

 

Police \= Fire,

Sanitation \= Fire,

{{out}}

<pre>P S F

 

=={{header|Nim}}==

 

iterator solutions(max, total: Positive): Solution =

echo "P S F"

for sol in solutions(7, 12):

 

{{out}}

=={{header|Objeck}}==

{{Trans|C++}}

function : Main(args : String[]) ~ Nil {

sol := 1;

};

}

 

Output:

 

=={{header|OCaml}}==

* Caution: This is my first Ocaml program and anyone with Ocaml experience probably thinks it's horrible

* So please don't use this as an example for "good ocaml code" see it more as

print_sfp_list result;

 

{{out}}

<pre>S F P

=={{header|PARI/GP}}==

 

{{out}}

<pre>2 3 7

=={{header|Perl}}==

 

#!/usr/bin/perl

 

}

}

 

 

Above Code cleaned up and shortened

 

#!/usr/bin/perl

 

}

}

 

Output:

Police - Fire - Sanitation

2 - 3 - 7

6 - 4 - 2

6 - 5 - 1

===Alternate with Regex===

 

use strict; # https://rosettacode.org/wiki/Department_numbers

/(.).* \s .*?(?!\1)(.).* \s .*(?!\1)(?!\2)(.)

(??{$1+$2+$3!=12})

{{out}}

<pre>

</pre>

===Alternate with Glob===

 

use strict; # https://rosettacode.org/wiki/Department_numbers

print tr/+/ /r, "\n" for

grep !/(\d).*\1/ && 12 == eval,

Output same as with Regex

 

=={{header|Phix}}==

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Police Sanitation Fire\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"------ ---------- ----\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n%d solutions found\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">solutions</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|PHP}}==

 

 

$valid = 0;

}

}

 

{{out}}

 

===Constraint model===

 

go ?=>

Police + Sanitation + Fire #= 12,

Police mod 2 #= 0,

 

{{out}}

 

===Loop===

println(" P S F"),

foreach(P in 1..N, P mod 2 == 0)

end

end

 

===List comprehension===

 

department_numbers3(N) =>

F in 1..N,

F != P, F != S, P + S + F == 12],

 

===Prolog style===

{{trans|Prolog}}

println("P F S"),

assign(Police, Fire, Sanitation),

police(A), fire(B), san(C),

A != B, A != C, B != C,

 

 

 

=={{header|PicoLisp}}==

(co 'numbers

(let N 7

(<> 12 (apply + L))

(println L) ) ) ) )

{{out}}

<pre>

 

===Pilog===

(member @Pol (2 4 6))

(for @Fire 1 7)

(^ @

(= 12

{{out}}

<pre>

 

=={{header|Prolog}}==

dept(X) :- between(1, 7, X).

 

 

?- main.

{{Out}}

<pre>

=={{header|Python}}==

===Procedural===

def solve():

if __name__ == '__main__':

 

{{out}}

Expressing the options directly and declaratively in terms of a ''bind'' operator, without importing ''permutations'':

{{Works with|Python|3}}

 

from itertools import (chain)

 

if __name__ == '__main__':

{{Out}}

<pre>('Police', 'Sanitation', 'Fire')

Nested ''bind'' (or ''concatMap'') expressions (like those above) can also be translated into list comprehension notation:

{{Works with|Python|3.7}}

 

from operator import ne

 

if __name__ == '__main__':

{{Out}}

<pre>('Police', 'Sanitation', 'Fire')

 

===Adapted from C# Example===

# We start with the Police Department.

# Range is the start, stop, and step. This returns only even numbers.

print("Police: ", p, " Sanitation:", f, " Fire: ", s)

 

{{Out}}

<pre>

{{trans|Forth}}

 

[ 2drop drop ] done

dip over swap over = iff

witheach police ] is departments ( --> )

 

 

{{out}}

=={{header|R}}==

We solve this task in two lines. The rest of the code is to make the result look nice.

solution <- allPermutations[which(rowSums(allPermutations)==12 & apply(allPermutations, 1, function(x) !any(duplicated(x)))),]

solution <- solution[order(solution$Police, solution$Sanitation),]

row.names(solution) <- paste0("Solution #", seq_len(nrow(solution)), ":")

 

{{out}}

We filter the Cartesian product of the lists of candidate department numbers.

 

(cons '(police fire sanitation)

(filter (λ (pfs) (and (not (check-duplicates pfs))

pfs))

(cartesian-product (range 2 8 2) (range 1 8) (range 1 8))))

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

for .permutations\ .grep(*.[0] %% 2) {

say <police fire sanitation> Z=> .list;

}

}

{{out}}

<pre>

=={{header|REXX}}==

This REXX example essentially uses brute force approach for so simple a puzzle.

say 'police sanitation fire' /*display simple title for the output*/

say '══════ ══════════ ════' /* " head separator " " " */

say '══════ ══════════ ════' /* " head separator " " " */

say /*stick a fork in it, we're all done. */

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

sanitation= 0

see "police fire sanitation" + nl

next

next

Output:

<pre>

 

=={{header|Ruby}}==

(1..7).to_a.permutation(3){|p| puts p.join if p.first.even? && p.sum == 12 }

{{Output}}

<pre>237

=={{header|Rust}}==

{{trans|C}}

fn main() {

println!("Police Sanitation Fire");

}

}

 

=={{header|Scala}}==

(1 to 7).permutations.map{ n => (n(0),n(1),n(2)) }.toList.distinct // All permutations of possible department numbers

.filter{ n => n._1 % 2 == 0 } // Keep only even numbers favored by Police Chief

println( depts.mkString("\n") )

}

{{output}}

<pre>(Police, Sanitation, Fire)

=={{header|Sidef}}==

{{trans|Raku}}

a.sum == 12 || next

a.permutations {|*b|

say (%w(police fire sanitation) ~Z b -> join(" "))

}

{{out}}

<pre>

Functional approach:

 

return (1...7)

.filter({ $0 != x })

for result in res {

print(result)

 

Iterative approach:

 

 

for x in [2, 4, 6] {

for result in res {

print(result)

 

{{out}}

 

<b>VERSION A</b> - using procedures and list operations

# Procedure named ".." returns list of integers from 1 to max.

proc .. max {

}

puts "$valid valid combinations found."

 

<b>VERSION B</b> - using simple for loops with number literals

set valid 0

for {set police 2} {$police <= 6} {incr police 2} {

}

puts "$valid valid combinations found."

 

<b>VERSION C</b> - using simple for loops with number variables

set min 1

set max 7

 

puts "$valid valid combinations found."

 

<b>VERSION D</b> - using list filter with lambda expressions

# Procedure named ".." returns list of integers from 1 to max.

proc .. max {

puts [join $numbersOk \n]

puts "[llength $numbersOk] valid combinations found."

{{output}}

All four versions (A, B, C and D) produce the same result:

 

=={{header|Tiny BASIC}}==

PRINT "------|----------|----"

10 LET P = P + 2

IF F < 7 THEN GOTO 30

IF S < 7 THEN GOTO 20

 

=={{header|Transd}}==

 

MainModule : {

(if (eq (+ i j k) 12) (lout i " " j " " k)))))

)

<pre>

Police | Sanit. | Fire

== {{header|TypeScript}} ==

{{trans|Sinclair ZX81 BASIC}}

// Department numbers

console.log(`POLICE SANITATION FIRE`);

}

}

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Main()

End Sub

 

{{out}}

<pre>Police:2, Sanitation:3, Fire:7

=={{header|Vlang}}==

{{trans|Go}}

println("Police Sanitation Fire")

println("------ ---------- ----")

}

println("\n$count valid combinations")

 

{{out}}

 

=={{header|VTL-2}}==

20 S=1

30 F=1

140 #=S<8*30

150 P=P+2

{{out}}

<pre>2 3 7

=={{header|Wren}}==

{{trans|Kotlin}}

System.print("------ ---------- ----")

var count = 0

}

}

 

{{out}}

{{trans|Sinclair ZX81 BASIC}}

{{works with|EXPL-32}}

\Department numbers

code CrLf=9, IntIn=10, IntOut=11, Text=12;

end;

end

{{out}}

<pre>

 

=={{header|zkl}}==

.filter(fcn(numbers){ numbers.sum(0)==12 }) // which all sum to 12 (==5)

{{output}}

<pre>

 

For a table with repeated solutions using nested loops:

foreach p,f,s in ([2..7,2], [1..7], [1..7])

{{out}}

<pre>