Casting out nines: Difference between revisions
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
Thundergnat (talk | contribs) m (Automated syntax highlighting fixup (second round - minor fixes)) |
||
Line 1: | Line 1: | ||
{{task}} |
{{task|Case Sensitivity}} |
||
[[Category:Checksums]] |
|||
Three dogs (Are there three dogs or one dog?) is a code snippet used to illustrate the lettercase sensitivity of the programming language. For a case-sensitive language, the identifiers dog, Dog and DOG are all different and we should get the output: |
|||
;Task (in three parts): |
|||
;Part 1 |
|||
Write a procedure (say <math>\mathit{co9}(x)</math>) which implements [https://web.archive.org/web/20120619091249/http://mathforum.org/library/drmath/view/55926.html Casting Out Nines] as described by returning the checksum for <math>x</math>. Demonstrate the procedure using the examples given there, or others you may consider lucky. |
|||
;Part 2 |
|||
Notwithstanding past Intel microcode errors, checking computer calculations like this would not be sensible. To find a computer use for your procedure: |
|||
: Consider the statement "318682 is 101558 + 217124 and squared is 101558217124" (see: [[Kaprekar numbers#Casting Out Nines (fast)]]). |
|||
: note that <math>318682</math> has the same checksum as (<math>101558 + 217124</math>); |
|||
: note that <math>101558217124</math> has the same checksum as (<math>101558 + 217124</math>) because for a Kaprekar they are made up of the same digits (sometimes with extra zeroes); |
|||
: note that this implies that for Kaprekar numbers the checksum of <math>k</math> equals the checksum of <math>k^2</math>. |
|||
Demonstrate that your procedure can be used to generate or filter a range of numbers with the property <math>\mathit{co9}(k) = \mathit{co9}(k^2)</math> and show that this subset is a small proportion of the range and contains all the Kaprekar in the range. |
|||
;Part 3 |
|||
Considering [http://mathworld.wolfram.com/CastingOutNines.html this MathWorld page], produce a efficient algorithm based on the more mathematical treatment of Casting Out Nines, and realizing: |
|||
: <math>\mathit{co9}(x)</math> is the residual of <math>x</math> mod <math>9</math>; |
|||
: the procedure can be extended to bases other than 9. |
|||
Demonstrate your algorithm by generating or filtering a range of numbers with the property <math>k%(\mathit{Base}-1) == (k^2)%(\mathit{Base}-1)</math> and show that this subset is a small proportion of the range and contains all the Kaprekar in the range. |
|||
<br> |
|||
;related tasks |
|||
* [[First perfect square in base N with N unique digits]] |
|||
* [[Kaprekar numbers]] |
|||
<br> |
|||
=={{header|11l}}== |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang=11l>F CastOut(Base, Start, End) |
|||
V ran = (0 .< Base - 1).filter(y -> y % (@Base - 1) == (y * y) % (@Base - 1)) |
|||
V (x, y) = divmod(Start, Base - 1) |
|||
[Int] r |
|||
L |
|||
L(n) ran |
|||
V k = (Base - 1) * x + n |
|||
I k < Start |
|||
L.continue |
|||
I k > End |
|||
R r |
|||
r.append(k) |
|||
x++ |
|||
L(v) CastOut(Base' 16, Start' 1, End' 255) |
|||
print(v, end' ‘ ’) |
|||
print() |
|||
L(v) CastOut(Base' 10, Start' 1, End' 99) |
|||
print(v, end' ‘ ’) |
|||
print() |
|||
L(v) CastOut(Base' 17, Start' 1, End' 288) |
|||
print(v, end' ‘ ’) |
|||
print()</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
<pre> |
||
The three dogs are named Benjamin, Samba and Bernie. |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255 |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 192 193 208 209 224 225 240 241 256 257 272 273 288 |
|||
</pre> |
</pre> |
||
For a language that is lettercase insensitive, we get the following output: |
|||
=={{header|360 Assembly}}== |
|||
{{trans|REXX}} |
|||
The program uses two ASSIST macros (XDECO,XPRNT) to keep the code as short as possible. |
|||
<syntaxhighlight lang=360asm>* Casting out nines 08/02/2017 |
|||
CASTOUT CSECT |
|||
USING CASTOUT,R13 base register |
|||
B 72(R15) skip savearea |
|||
DC 17F'0' savearea |
|||
STM R14,R12,12(R13) prolog |
|||
ST R13,4(R15) " <- |
|||
ST R15,8(R13) " -> |
|||
LR R13,R15 " addressability |
|||
L R1,LOW low |
|||
XDECO R1,XDEC edit low |
|||
MVC PGT+4(4),XDEC+8 output low |
|||
L R1,HIGH high |
|||
XDECO R1,XDEC edit high |
|||
MVC PGT+12(4),XDEC+8 output low |
|||
L R1,BASE base |
|||
XDECO R1,XDEC edit base |
|||
MVC PGT+24(4),XDEC+8 output base |
|||
XPRNT PGT,L'PGT print buffer |
|||
L R2,BASE base |
|||
BCTR R2,0 -1 |
|||
ST R2,RM rm=base-1 |
|||
LA R8,PG ipg=0 |
|||
SR R7,R7 j=0 |
|||
L R6,LOW i=low |
|||
DO WHILE=(C,R6,LE,HIGH) do i=low to high |
|||
LR R5,R6 i |
|||
SR R4,R4 clear for div |
|||
D R4,RM /rm |
|||
LR R2,R4 r2=i mod rm |
|||
LR R5,R6 i |
|||
MR R4,R6 i*i |
|||
SR R4,R4 clear for div |
|||
D R4,RM /rm |
|||
IF CR,R2,EQ,R4 THEN if (i//rm)=(i*i//rm) then |
|||
LA R7,1(R7) j=j+1 |
|||
XDECO R6,XDEC edit i |
|||
MVC 0(4,R8),XDEC+8 output i |
|||
LA R8,4(R8) ipg=ipg+4 |
|||
IF C,R7,EQ,=F'20' THEN if j=20 then |
|||
XPRNT PG,L'PG print buffer |
|||
LA R8,PG ipg=0 |
|||
SR R7,R7 j=0 |
|||
MVC PG,=CL80' ' clear buffer |
|||
ENDIF , end if |
|||
ENDIF , end if |
|||
LA R6,1(R6) i=i+1 |
|||
ENDDO , end do i |
|||
IF LTR,R7,NE,R7 THEN if j<>0 then |
|||
XPRNT PG,L'PG print buffer |
|||
ENDIF , end if |
|||
L R13,4(0,R13) epilog |
|||
LM R14,R12,12(R13) " restore |
|||
XR R15,R15 " rc=0 |
|||
BR R14 exit |
|||
LOW DC F'1' low |
|||
HIGH DC F'500' high |
|||
BASE DC F'10' base |
|||
RM DS F rm |
|||
PGT DC CL80'for ... to ... base ...' buffer |
|||
PG DC CL80' ' buffer |
|||
XDEC DS CL12 temp for xdeco |
|||
YREGS |
|||
END CASTOUT</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
<pre> |
||
There is just one dog named Bernie. |
|||
for 1 to 500 base 10 |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 |
|||
91 99 100 108 109 117 118 126 127 135 136 144 145 153 154 162 163 171 172 180 |
|||
181 189 190 198 199 207 208 216 217 225 226 234 235 243 244 252 253 261 262 270 |
|||
271 279 280 288 289 297 298 306 307 315 316 324 325 333 334 342 343 351 352 360 |
|||
361 369 370 378 379 387 388 396 397 405 406 414 415 423 424 432 433 441 442 450 |
|||
451 459 460 468 469 477 478 486 487 495 496 |
|||
</pre> |
</pre> |
||
;Related task: |
|||
* [[Unicode variable names]] |
|||
<br><br> |
|||
=={{header|11l}}== |
|||
11l identifiers are case sensitive. |
|||
<syntaxhighlight lang="11l">V dog = ‘Benjamin’ |
|||
V Dog = ‘Samba’ |
|||
V DOG = ‘Bernie’ |
|||
print(‘The three dogs are named ’dog‘, ’Dog‘ and ’DOG‘.’)</syntaxhighlight> |
|||
=={{header|Action!}}== |
=={{header|Action!}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="action!">PROC Main() |
||
CHAR ARRAY dog="Bernie" |
|||
INT i,res |
|||
PrintF("There is just one dog named %S.",dog) |
|||
res=1 |
|||
FOR i=1 TO b |
|||
DO |
|||
res==*a |
|||
OD |
|||
RETURN (res) |
|||
PROC Main() |
|||
DEFINE BASE="10" |
|||
DEFINE N="2" |
|||
INT i,max,count,total,perc |
|||
max=Power(BASE,N) |
|||
count=0 total=0 |
|||
FOR i=1 TO max |
|||
DO |
|||
total==+1 |
|||
IF i MOD (BASE-1)=(i*i) MOD (BASE-1) THEN |
|||
count==+1 |
|||
PrintI(i) Put(32) |
|||
FI |
|||
OD |
|||
perc=100-100*count/total |
|||
PrintF("%E%ETrying %I numbers instead of %I numbers saves %I%%",count,total,perc) |
|||
RETURN</syntaxhighlight> |
RETURN</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/ |
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Case-sensitivity_of_identifiers.png Screenshot from Atari 8-bit computer] |
||
<pre> |
<pre> |
||
There is just one dog named Bernie. |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100 |
|||
Trying 23 numbers instead of 100 numbers saves 77% |
|||
</pre> |
</pre> |
||
=={{header|Ada}}== |
|||
case insensitive |
|||
<syntaxhighlight lang="ada">with Ada.Text_IO; |
|||
procedure Dogs is |
|||
Dog : String := "Bernie"; |
|||
begin |
|||
Ada.Text_IO.Put_Line ("There is just one dog named " & DOG); |
|||
end Dogs;</syntaxhighlight> |
|||
Output: |
|||
=={{header|ALGOL 68}}== |
|||
<pre>There is just one dog named Bernie</pre> |
|||
{{Trans|Action!}} |
|||
=={{header|Agena}}== |
|||
<syntaxhighlight lang=algol68>BEGIN # casting out nines - translated from the Action! sample # |
|||
Translation of Algol W. Agena is case sensitive, as this example demonstrates. Tested with Agena 2.9.5 Win32 |
|||
INT base = 10; |
|||
<syntaxhighlight lang="agena">scope |
|||
INT n = 2; |
|||
local dog := "Benjamin"; |
|||
scope |
|||
INT total := 0; |
|||
local Dog := "Samba"; |
|||
scope |
|||
local DOG := "Bernie"; |
|||
if DOG <> Dog or DOG <> dog |
|||
print( |
then print( "The three dogs are named: " & dog & ", " & Dog & " and " & DOG ) |
||
else print( "There is just one dog named: " & DOG ) |
|||
FI |
|||
fi |
|||
epocs |
|||
print( ( newline, newline, "Trying ", whole( count, 0 ) |
|||
epocs |
|||
, " numbers instead of ", whole( total, 0 ) |
|||
epocs</syntaxhighlight> |
|||
, " numbers saves ", fixed( 100 - ( ( 100 * count ) / total ), -6, 2 ) |
|||
, "%", newline |
|||
) |
|||
) |
|||
END</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
The three dogs are named: Benjamin, Samba and Bernie |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100 |
|||
Trying 23 numbers instead of 100 numbers saves 77.00% |
|||
</pre> |
</pre> |
||
=={{header|Aime}}== |
|||
<syntaxhighlight lang="aime">text dog, Dog, DOG; |
|||
dog = "Benjamin"; |
|||
=={{header|Arturo}}== |
|||
Dog = "Samba"; |
|||
DOG = "Bernie"; |
|||
o_form("The three dogs are named ~, ~ and ~.\n", dog, Dog, DOG);</syntaxhighlight> |
|||
<syntaxhighlight lang=rebol>N: 2 |
|||
=={{header|ALGOL 68}}== |
|||
base: 10 |
|||
{{works with|ALGOL 68|Revision 1.}} |
|||
c1: 0 |
|||
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.6 algol68g-2.6].}} |
|||
c2: 0 |
|||
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}} |
|||
A joke code entry... :-) ¢ but the code does actually work! |
|||
'''File: Case-sensitivity_of_identifiers.a68'''<syntaxhighlight lang="algol68">#!/usr/bin/a68g --script # |
|||
# -*- coding: utf-8 -*- # |
|||
STRING dog = "Benjamin"; |
|||
OP D = (INT og)STRING: "Samba"; |
|||
OP DOG = (INT gy)STRING: "Bernie"; |
|||
INT og=~, gy=~; |
|||
main:( |
|||
loop 1..(base^N)-1 'k [ |
|||
printf(($"The three dogs are named "g", "g" and "g"."l$, dog, Dog, DOGgy)); |
|||
c1: c1 + 1 |
|||
0 |
|||
)</syntaxhighlight>'''Output:''' |
|||
<pre> |
|||
The three dogs are named Benjamin, Samba and Bernie. |
|||
</pre> |
|||
Alternative version. |
|||
if (k%base-1)= (k*k)%base-1 [ |
|||
<br> |
|||
c2: c2 + 1 |
|||
{{works with|Rutgers_ALGOL_68|Any - Tested with the DOS version}} |
|||
prints ~"|k| " |
|||
{{Trans|Algol W}} |
|||
] |
|||
Most recent implementations of Algol 68 use "upper stropping", the "keywords" are in upper case and the identifiers are an lower case. This precludes use of e.g. Dog or DOG as the name of a variable or constant. |
|||
] |
|||
<br> |
|||
However, depending on the "stropping" convention used and the implementation, Algol 68 can be case-sensitive. Rutgers ALGOL 68 uses quote stropping and allows both upper and lower case in identifiers and bold words. The standard bold words must be in lower-case. |
|||
print "" |
|||
<syntaxhighlight lang="algol68">'begin' |
|||
print ["Trying" c2 "numbers instead of" c1 "numbers saves" 100.0 - 100.0*c2//c1 "%"]</syntaxhighlight> |
|||
'string' dog = "Benjamin"; |
|||
'begin' |
|||
'string' Dog = "Samba"; |
|||
'begin' |
|||
'string' DOG = "Bernie"; |
|||
'if' DOG /= Dog 'or' DOG /= dog |
|||
'then' print( ( "The three dogs are named: ", dog, ", ", Dog, " and ", DOG ) ) |
|||
'else' print( ( "There is just one dog named: ", DOG ) ) |
|||
'fi' |
|||
'end' |
|||
'end' |
|||
'end'</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre> |
|||
The three dogs are named: Benjamin, Samba and Bernie |
|||
<pre>1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
</pre> |
|||
Trying 22 numbers instead of 99 numbers saves 77.77777777777777 %</pre> |
|||
=={{header|ALGOL W}}== |
|||
Algol W identifiers are not case-sensitive but variable names in inner blocks can be the same as those in outer blocks... |
|||
=={{header|AWK}}== |
|||
<syntaxhighlight lang= |
<syntaxhighlight lang="algolw">begin |
||
string(8) dog; |
|||
# syntax: GAWK -f CASTING_OUT_NINES.AWK |
|||
dog := "Benjamin"; |
|||
# converted from C |
|||
begin |
|||
BEGIN { |
|||
string(8) Dog; |
|||
Dog := "Samba"; |
|||
for (k=1; k<=base^2; k++) { |
|||
begin |
|||
string(8) DOG; |
|||
DOG := "Bernie"; |
|||
if DOG not = Dog |
|||
or DOG not = dog |
|||
then write( "The three dogs are named: ", dog, ", ", Dog, " and ", DOG ) |
|||
} |
|||
else write( "There is just one dog named: ", DOG ) |
|||
printf("\nTrying %d numbers instead of %d numbers saves %.2f%%\n",c2,c1,100-(100*c2/c1)) |
|||
end |
|||
end |
|||
} |
|||
</syntaxhighlight> |
end.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
There is just one dog named: Bernie |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100 |
|||
Trying 23 numbers instead of 100 numbers saves 77.00% |
|||
</pre> |
</pre> |
||
=={{header|APL}}== |
|||
<syntaxhighlight lang="apl"> DOG←'Benjamin' |
|||
Dog←'Samba' |
|||
dog←'Bernie' |
|||
'The three dogs are named ',DOG,', ',Dog,', and ',dog |
|||
The three dogs are named Benjamin, Samba, and Bernie</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">dog: "Benjamin" |
|||
=={{header|C}}== |
|||
Dog: "Samba" |
|||
{{trans|C++}} |
|||
DOG: "Bernie" |
|||
<syntaxhighlight lang=c>#include <stdio.h> |
|||
#include <math.h> |
|||
dogs: @[dog Dog DOG] |
|||
int main() { |
|||
const int N = 2; |
|||
int base = 10; |
|||
int c1 = 0; |
|||
int c2 = 0; |
|||
int k; |
|||
print ["The" size dogs "dog(s) are named" join.with:", " dogs]</syntaxhighlight> |
|||
for (k = 1; k < pow(base, N); k++) { |
|||
c1++; |
|||
if (k % (base - 1) == (k * k) % (base - 1)) { |
|||
c2++; |
|||
printf("%d ", k); |
|||
} |
|||
} |
|||
printf("\nTring %d numbers instead of %d numbers saves %f%%\n", c2, c1, 100.0 - 100.0 * c2 / c1); |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre>1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
Tring 22 numbers instead of 99 numbers saves 77.777778%</pre> |
|||
<pre>The 3 dog(s) are named Benjamin, Samba, Bernie</pre> |
|||
=={{header|C++}}== |
|||
=={{header|AutoHotkey}}== |
|||
===Filter=== |
|||
<syntaxhighlight lang= |
<syntaxhighlight lang="autohotkey">dog := "Benjamin" |
||
Dog := "Samba" |
|||
// |
|||
DOG := "Bernie" |
|||
// Nigel Galloway. June 24th., 2012 |
|||
MsgBox There is just one dog named %dOG%</syntaxhighlight> |
|||
// |
|||
=={{header|AWK}}== |
|||
#include <iostream> |
|||
<syntaxhighlight lang="awk">BEGIN { |
|||
int main() { |
|||
dog = "Benjamin" |
|||
int Base = 10; |
|||
Dog = "Samba" |
|||
const int N = 2; |
|||
DOG = "Bernie" |
|||
printf "The three dogs are named %s, %s and %s.\n", dog, Dog, DOG |
|||
int c2 = 0; |
|||
for (int k=1; k<pow((double)Base,N); k++){ |
|||
c1++; |
|||
if (k%(Base-1) == (k*k)%(Base-1)){ |
|||
c2++; |
|||
std::cout << k << " "; |
|||
} |
|||
} |
|||
std::cout << "\nTrying " << c2 << " numbers instead of " << c1 << " numbers saves " << 100 - ((double)c2/c1)*100 << "%" <<std::endl; |
|||
return 0; |
|||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
{{out|Produces}} |
|||
<pre> |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
Trying 22 numbers instead of 99 numbers saves 77.7778% |
|||
</pre> |
|||
The kaprekar numbers in this range 1 9 45 55 and 99 are included. |
|||
The three dogs are named Benjamin, Samba and Bernie. |
|||
Changing: "<code>int Base = 16;</code>" Produces: |
|||
=={{header|BASIC}}== |
|||
<pre> |
|||
{{works with|QBasic}} |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 |
|||
QBASIC is case-insensitive |
|||
105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 |
|||
<syntaxhighlight lang="basic256">DOG$ = "Benjamin" |
|||
180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 |
|||
DOG$ = "Samba" |
|||
255 |
|||
DOG$ = "Bernie" |
|||
Trying 68 numbers instead of 255 numbers saves 73.3333% |
|||
PRINT "There is just one dog, named "; DOG$</syntaxhighlight> |
|||
</pre> |
|||
=={{header|BASIC256}}== |
|||
The kaprekar numbers: |
|||
BASIC256 is case-insensitive |
|||
:1 is 1 |
|||
<syntaxhighlight lang="basic256">dog = "Benjamin" |
|||
:6 is 6 |
|||
Dog = "Samba" |
|||
:a is 10 |
|||
DOG = "Bernie" |
|||
:f is 15 |
|||
print "There is just one dog, named "; dog |
|||
:33 is 51 |
|||
end</syntaxhighlight> |
|||
:55 is 85 |
|||
=={{header|Batch File}}== |
|||
:5b is 91 |
|||
<syntaxhighlight lang="dos"> |
|||
:78 is 120 |
|||
@echo off |
|||
:88 is 136 |
|||
:ab is 171 |
|||
:cd is 205 |
|||
:ff is 255 |
|||
set dog=Benjamin |
|||
in this range are included. |
|||
set Dog=Samba |
|||
set DOG=Bernie |
|||
echo There is just one dog named %dog%. |
|||
Changing: "<code>int Base = 17;</code>" Produces: |
|||
pause>nul |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
<pre> |
||
There is just one dog named Bernie. |
|||
1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 19 |
|||
2 193 208 209 224 225 240 241 256 257 272 273 288 |
|||
Trying 36 numbers instead of 288 numbers saves 87.5% |
|||
</pre> |
</pre> |
||
=={{header|BBC BASIC}}== |
|||
The kaprekar numbers: |
|||
<syntaxhighlight lang="bbcbasic"> dog$ = "Benjamin" |
|||
:1 is 1 |
|||
Dog$ = "Samba" |
|||
:g is 16 |
|||
DOG$ = "Bernie" |
|||
:3d is 64 |
|||
PRINT "The three dogs are " dog$ ", " Dog$ " and " DOG$ "."</syntaxhighlight> |
|||
:d4 is 225 |
|||
Output: |
|||
:gg is 288 |
|||
<pre>The three dogs are Benjamin, Samba and Bernie.</pre> |
|||
=={{header|bc}}== |
|||
The only variables are 'a' through 'z'. They can only hold numbers, not strings. Some implementations allow longer names like 'dog', but only with lowercase letters. A name like 'Dog' or 'DOG' is a syntax error. |
|||
<syntaxhighlight lang="bc">obase = 16 |
|||
in this range are included. |
|||
ibase = 16 |
|||
===C++11 For Each Generator=== |
|||
<syntaxhighlight lang=cpp>// Casting Out Nines Generator - Compiles with gcc4.6, MSVC 11, and CLang3 |
|||
// |
|||
// Nigel Galloway. June 24th., 2012 |
|||
// |
|||
#include <iostream> |
|||
#include <vector> |
|||
struct ran { |
|||
const int base; |
|||
std::vector<int> rs; |
|||
ran(const int base) : base(base) { for (int nz=0; nz<base-1; nz++) if(nz*(nz-1)%(base-1) == 0) rs.push_back(nz); } |
|||
}; |
|||
class co9 { |
|||
private: |
|||
const ran* _ran; |
|||
const int _end; |
|||
int _r,_x,_next; |
|||
public: |
|||
bool operator!=(const co9& other) const {return operator*() <= _end;} |
|||
co9 begin() const {return *this;} |
|||
co9 end() const {return *this;} |
|||
int operator*() const {return _next;} |
|||
co9(const int start, const int end, const ran* r) |
|||
:_ran(r) |
|||
,_end(end) |
|||
,_r(1) |
|||
,_x(start/_ran->base) |
|||
,_next((_ran->base-1)*_x + _ran->rs[_r]) |
|||
{ |
|||
while (operator*() < start) operator++(); |
|||
} |
|||
const co9& operator++() { |
|||
const int oldr = _r; |
|||
_r = ++_r%_ran->rs.size(); |
|||
if (_r<oldr) _x++; |
|||
_next = (_ran->base-1)*_x + _ran->rs[_r]; |
|||
return *this; |
|||
} |
|||
}; |
|||
/* |
|||
int main() { |
|||
* Store the hexadecimal number 'BE27A312' |
|||
ran r(10); |
|||
* in the variable 'd'. |
|||
for (int i : co9(1,99,&r)) { std::cout << i << ' '; } |
|||
*/ |
|||
return 0; |
|||
d = BE27A312 |
|||
}</syntaxhighlight> |
|||
"There is just one dog named "; d |
|||
{{out|Produces}} |
|||
quit</syntaxhighlight> |
|||
<pre> |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
</pre> |
|||
An alternative implementation for struct ran using http://rosettacode.org/wiki/Sum_digits_of_an_integer#C.2B.2B which produces the same result is: |
|||
<syntaxhighlight lang=cpp>struct ran { |
|||
const int base; |
|||
std::vector<int> rs; |
|||
ran(const int base) : base(base) { for (int nz=0; nz<base-1; nz++) if(SumDigits(nz) == SumDigits(nz*nz)) rs.push_back(nz); } |
|||
};</syntaxhighlight> |
|||
Changing main: |
|||
<syntaxhighlight lang=cpp>int main() { |
|||
ran r(16); |
|||
for (int i : co9(1,255,&r)) { std::cout << i << ' '; } |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
{{out|Produces}} |
|||
<pre> |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255 |
|||
</pre> |
|||
Changing main: |
|||
<syntaxhighlight lang=cpp>int main() { |
|||
ran r(17); |
|||
for (int i : co9(1,288,&r)) { std::cout << i << ' '; } |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
{{out|Produces}} |
|||
<pre> |
|||
1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 192 193 208 209 224 225 240 241 256 257 272 273 288 |
|||
</pre> |
|||
There is just one dog named BE27A312 |
|||
=={{header|C sharp|C#}}== |
|||
{{ |
=={{header|Bracmat}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="bracmat">( Benjamin:?dog |
||
& Samba:?Dog |
|||
using System.Collections.Generic; |
|||
& Bernie:?DOG |
|||
using System.Linq; |
|||
& out$("There are three dogs:" !dog !Dog and !DOG) |
|||
using System.Text; |
|||
);</syntaxhighlight> |
|||
Output: |
|||
<pre>There are three dogs: Benjamin Samba and Bernie</pre> |
|||
=={{header|Brlcad}}== |
|||
The three dogs are drawn as spheres in this simple example: |
|||
namespace CastingOutNines { |
|||
public static class Helper { |
|||
public static string AsString<T>(this IEnumerable<T> e) { |
|||
var it = e.GetEnumerator(); |
|||
<syntaxhighlight lang="mged"> |
|||
StringBuilder builder = new StringBuilder(); |
|||
opendb dogs.g y # Create a database to hold our dogs |
|||
builder.Append("["); |
|||
units ft # The dogs are measured in feet |
|||
in dog.s sph 0 0 0 1 # Benjie is a little Scottie dog |
|||
in Dog.s sph 4 0 0 3 # Samba is a Labrador |
|||
in DOG.s sph 13 0 0 5 # Bernie is massive. He is a New Foundland |
|||
echo The three dogs are named Benjamin, Samba and Bernie</syntaxhighlight> |
|||
=={{header|C}}== |
|||
C is case sensitive; if it would be case insensitive, an error about redefinition of a variable would be raised. |
|||
<syntaxhighlight lang="c">#include <stdio.h> |
|||
if (it.MoveNext()) { |
|||
builder.Append(it.Current); |
|||
} |
|||
while (it.MoveNext()) { |
|||
builder.Append(", "); |
|||
builder.Append(it.Current); |
|||
} |
|||
static const char *dog = "Benjamin"; |
|||
builder.Append("]"); |
|||
static const char *Dog = "Samba"; |
|||
return builder.ToString(); |
|||
static const char *DOG = "Bernie"; |
|||
} |
|||
} |
|||
int main() |
|||
class Program { |
|||
{ |
|||
static List<int> CastOut(int @base, int start, int end) { |
|||
printf("The three dogs are named %s, %s and %s.\n", dog, Dog, DOG); |
|||
int[] ran = Enumerable |
|||
return 0; |
|||
.Range(0, @base - 1) |
|||
}</syntaxhighlight> |
|||
.Where(a => a % (@base - 1) == (a * a) % (@base - 1)) |
|||
=={{header|C sharp|C#}}== |
|||
.ToArray(); |
|||
C# is case sensitive |
|||
int x = start / (@base - 1); |
|||
<syntaxhighlight lang="c sharp"> |
|||
using System; |
|||
class Program |
|||
List<int> result = new List<int>(); |
|||
{ |
|||
while (true) { |
|||
static void Main(string[] args) |
|||
foreach (int n in ran) { |
|||
{ |
|||
int k = (@base - 1) * x + n; |
|||
string dog = "Benjamin"; |
|||
string Dog = "Samba"; |
|||
string DOG = "Bernie"; |
|||
Console.WriteLine(string.Format("The three dogs are named {0}, {1}, and {2}.", dog, Dog, DOG)); |
|||
if (k > end) { |
|||
return result; |
|||
} |
|||
result.Add(k); |
|||
} |
|||
x++; |
|||
} |
|||
} |
|||
static void Main() { |
|||
Console.WriteLine(CastOut(16, 1, 255).AsString()); |
|||
Console.WriteLine(CastOut(10, 1, 99).AsString()); |
|||
Console.WriteLine(CastOut(17, 1, 288).AsString()); |
|||
} |
|||
} |
} |
||
}</syntaxhighlight> |
|||
=={{header|C++}}== |
|||
C++ is case-sensitive. |
|||
<syntaxhighlight lang="cpp">#include <iostream> |
|||
#include <string> |
|||
using namespace std; |
|||
int main() { |
|||
string dog = "Benjamin", Dog = "Samba", DOG = "Bernie"; |
|||
cout << "The three dogs are named " << dog << ", " << Dog << ", and " << DOG << endl; |
|||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>The three dogs are named Benjamin, Samba, and Bernie</pre> |
|||
<pre>[1, 6, 10, 15, 16, 21, 25, 30, 31, 36, 40, 45, 46, 51, 55, 60, 61, 66, 70, 75, 76, 81, 85, 90, 91, 96, 100, 105, 106, 111, 115, 120, 121, 126, 130, 135, 136, 141, 145, 150, 151, 156, 160, 165, 166, 171, 175, 180, 181, 186, 190, 195, 196, 201, 205, 210, 211, 216, 220, 225, 226, 231, 235, 240, 241, 246, 250, 255] |
|||
=={{header|Clojure}}== |
|||
[1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, 81, 82, 90, 91, 99] |
|||
<pre>user=> (let [dog "Benjamin" Dog "Samba" DOG "Bernie"] (format "The three dogs are named %s, %s and %s." dog Dog DOG)) |
|||
[1, 16, 17, 32, 33, 48, 49, 64, 65, 80, 81, 96, 97, 112, 113, 128, 129, 144, 145, 160, 161, 176, 177, 192, 193, 208, 209, 224, 225, 240, 241, 256, 257, 272, 273, 288]</pre> |
|||
"The three dogs are named Benjamin, Samba and Bernie."</pre> |
|||
=={{header|COBOL}}== |
|||
<syntaxhighlight lang="cobol *">* Case sensitivity of identifiers |
|||
*>* Commented-out lines in the working storage |
|||
*>* are considered as invalid redefinitions |
|||
*>* of ''dog'' that can only be ambiguously |
|||
*>* referenced in the procedure body. |
|||
IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. case-sensitivity. |
|||
DATA DIVISION. |
|||
WORKING-STORAGE SECTION. |
|||
*>* 01 dog PICTURE X(8) VALUE IS "Benjamin". |
|||
*>* 01 Dog PICTURE X(5) VALUE IS "Samba". |
|||
01 DOG PICTURE X(6) VALUE IS "Bernie". |
|||
PROCEDURE DIVISION. |
|||
DISPLAY |
|||
*>* "The three dogs are named " |
|||
*>* dog ", " Dog " and " DOG "." |
|||
"There is just one dog named " DOG "." |
|||
END-DISPLAY |
|||
STOP RUN. |
|||
END PROGRAM case-sensitivity.</syntaxhighlight> |
|||
=={{header|CoffeeScript}}== |
|||
<syntaxhighlight lang="coffeescript"> |
|||
dog="Benjamin" |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
console.log "The three dogs are names #{dog}, #{Dog}, and #{DOG}." |
|||
</syntaxhighlight> |
|||
output |
|||
<syntaxhighlight lang="text"> |
|||
> coffee foo.coffee |
|||
The three dogs are names Benjamin, Samba, and Bernie. |
|||
</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
<syntaxhighlight lang=lisp> |
<syntaxhighlight lang="lisp">CL-USER> (let* ((dog "Benjamin") (Dog "Samba") (DOG "Bernie")) |
||
(format nil "There is just one dog named ~a." dog)) |
|||
;;Larry Hignight. Last updated on 7/3/2012. |
|||
; in: LAMBDA NIL |
|||
(defmacro kaprekar-number-filter (n &optional (base 10)) |
|||
; (LET* ((DOG "Benjamin") (DOG "Samba") (DOG "Bernie")) |
|||
; (FORMAT NIL "There is just one dog named ~a." DOG)) |
|||
; |
|||
; caught STYLE-WARNING: |
|||
; The variable DOG is defined but never used. |
|||
; |
|||
; caught STYLE-WARNING: |
|||
; The variable DOG is defined but never used. |
|||
; |
|||
; compilation unit finished |
|||
; caught 2 STYLE-WARNING conditions |
|||
"There is just one dog named Bernie."</syntaxhighlight> |
|||
These are the style warnings from [[SBCL]]. Other implementations of Common Lisp might give different warnings. |
|||
=={{header|Crystal}}== |
|||
<syntaxhighlight lang="crystal">dog = "Benjamin" |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
puts "The three dogs are named #{dog}, #{Dog} and #{DOG}."</syntaxhighlight> |
|||
Note that in Crystal, variables with all-caps identifiers (like <code>DOG</code>) are always constants. |
|||
(defun test (&key (start 1) (stop 10000) (base 10) (collect t)) |
|||
(let ((count 0) |
|||
(nums)) |
|||
(loop for i from start to stop do |
|||
(when (kaprekar-number-filter i base) |
|||
(if collect (push i nums)) |
|||
(incf count))) |
|||
(format t "~d potential Kaprekar numbers remain (~~~$% filtered out).~%" |
|||
count (* (/ (- stop count) stop) 100)) |
|||
(if collect (reverse nums))))</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre>The three dogs are named Benjamin, Samba and Bernie.</pre> |
|||
<pre>CL-USER> (test :stop 99) |
|||
22 potential Kaprekar numbers remain (~77.78% filtered out). |
|||
(1 9 10 18 19 27 28 36 37 45 ...) |
|||
CL-USER> (test :stop 10000 :collect nil) |
|||
2223 potential Kaprekar numbers remain (~77.77% filtered out). |
|||
NIL |
|||
CL-USER> (test :stop 1000000 :collect nil) |
|||
222223 potential Kaprekar numbers remain (~77.78% filtered out). |
|||
NIL |
|||
CL-USER> (test :stop 255 :base 16) |
|||
68 potential Kaprekar numbers remain (~73.33% filtered out). |
|||
(1 6 10 15 16 21 25 30 31 36 ...) |
|||
CL-USER> (test :stop 288 :base 17) |
|||
36 potential Kaprekar numbers remain (~87.50% filtered out). |
|||
(1 16 17 32 33 48 49 64 65 80 ...)</pre> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
<syntaxhighlight lang="d">import std.stdio; |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang=d>import std.stdio, std.algorithm, std.range; |
|||
uint[] castOut(in uint base=10, in uint start=1, in uint end=999999) { |
|||
auto ran = iota(base - 1) |
|||
.filter!(x => x % (base - 1) == (x * x) % (base - 1)); |
|||
auto x = start / (base - 1); |
|||
immutable y = start % (base - 1); |
|||
typeof(return) result; |
|||
while (true) { |
|||
foreach (immutable n; ran) { |
|||
immutable k = (base - 1) * x + n; |
|||
if (k < start) |
|||
continue; |
|||
if (k > end) |
|||
return result; |
|||
result ~= k; |
|||
} |
|||
x++; |
|||
} |
|||
} |
|||
void main() { |
void main() { |
||
string dog = "Benjamin"; |
|||
// identifiers that start with capital letters are type names |
|||
castOut(10, 1, 99).writeln; |
|||
string Dog = "Samba"; |
|||
string DOG = "Bernie"; |
|||
writefln("There are three dogs named ", |
|||
dog, ", ", Dog, ", and ", DOG, "'"); |
|||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
Output: |
|||
{{out|Output (some newlines added)}} |
|||
<pre>There are three dogs named Benjamin, Samba, and Bernie'</pre> |
|||
<pre>[1, 6, 10, 15, 16, 21, 25, 30, 31, 36, 40, 45, 46, 51, 55, 60, |
|||
=={{header|dc}}== |
|||
61, 66, 70, 75, 76, 81, 85, 90, 91, 96, 100, 105, 106, 111, 115, |
|||
A register name has only one character, so this example uses 'd' and 'D'. |
|||
120, 121, 126, 130, 135, 136, 141, 145, 150, 151, 156, 160, 165, |
|||
166, 171, 175, 180, 181, 186, 190, 195, 196, 201, 205, 210, 211, |
|||
216, 220, 225, 226, 231, 235, 240, 241, 246, 250, 255] |
|||
[1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, |
|||
81, 82, 90, 91, 99] |
|||
[1, 16, 17, 32, 33, 48, 49, 64, 65, 80, 81, 96, 97, 112, 113, 128, |
|||
129, 144, 145, 160, 161, 176, 177, 192, 193, 208, 209, 224, 225, |
|||
240, 241, 256, 257, 272, 273, 288]</pre> |
|||
<syntaxhighlight lang="dc">[Benjamin]sd |
|||
[Samba]sD |
|||
[The two dogs are named ]P ldP [ and ]P lDP [. |
|||
]P</syntaxhighlight> |
|||
{{Out}} |
|||
=={{header|FreeBASIC}}== |
|||
<pre>The two dogs are named Benjamin and Samba.</pre> |
|||
<syntaxhighlight lang=freebasic>Const base10 = 10 |
|||
=={{header|Delphi}}== |
|||
Dim As Integer c1 = 0, c2 = 0, k = 1 |
|||
Delphi is case insensitive. |
|||
<syntaxhighlight lang="delphi">program CaseSensitiveIdentifiers; |
|||
For k = 1 To base10^2 |
|||
c1 += 1 |
|||
If (k Mod (base10-1) = (k*k) Mod (base10-1)) Then c2 += 1: Print k;" "; |
|||
Next k |
|||
Print |
|||
Print Using "Intentar ## numeros en lugar de ### numeros ahorra un ##.##%"; c2; c1; 100-(100*c2/c1) |
|||
Sleep</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100 |
|||
Intentar 23 numeros en lugar de 100 numeros ahorra un 77.00% |
|||
</pre> |
|||
{$APPTYPE CONSOLE} |
|||
=={{header|Free Pascal}}== |
|||
<syntaxhighlight lang=pascal>program castout9; |
|||
{$ifdef fpc}{$mode delphi}{$endif} |
|||
uses generics.collections; |
|||
type |
|||
TIntegerList = TSortedList<integer>; |
|||
procedure co9(const start,base,lim:integer;kaprekars:array of integer); |
|||
var |
var |
||
dog: string; |
|||
C2:integer = 0; |
|||
S:TIntegerlist; |
|||
k,i:integer; |
|||
begin |
begin |
||
dog := 'Benjamin'; |
|||
S:=TIntegerlist.Create; |
|||
Dog := 'Samba'; |
|||
DOG := 'Bernie'; |
|||
begin |
|||
Writeln('There is just one dog named ' + dog); |
|||
inc(C1); |
|||
end.</syntaxhighlight> |
|||
if k mod (base-1) = (k*k) mod (base-1) then |
|||
begin |
|||
inc(C2); |
|||
S.Add(k); |
|||
end; |
|||
end; |
|||
writeln('Valid subset: '); |
|||
for i in Kaprekars do |
|||
if not s.contains(i) then |
|||
writeln('invalid ',i); |
|||
for i in s do write(i:4); |
|||
writeln; |
|||
write('The Kaprekars in this range ['); |
|||
for i in kaprekars do write(i:4); |
|||
writeln('] are included'); |
|||
writeln('Trying ',C2, ' numbers instead of ', C1,' saves ',100-(C2 * 100 /C1):3:2,',%.'); |
|||
writeln; |
|||
S.Free; |
|||
end; |
|||
begin |
|||
co9(1, 10, 99, [1,9,45,55,99]); |
|||
co9(1, 10, 1000, [1,9,45,55,99,297,703,999]); |
|||
end.</syntaxhighlight> |
|||
<pre> |
|||
Output: |
Output: |
||
<pre>There is just one dog named Bernie</pre> |
|||
Valid subset: |
|||
=={{header|DWScript}}== |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
<syntaxhighlight lang="delphi"> |
|||
The Kaprekars in this range [ 1 9 45 55 99] are included |
|||
var dog : String; |
|||
Trying 22 numbers instead of 99 saves 77.78,%. |
|||
dog := 'Benjamin'; |
|||
Valid subset: |
|||
Dog := 'Samba'; |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100 108 109 117 118 126 127 135 136 144 145 153 154 162 163 171 172 180 181 189 190 198 199 207 208 216 217 225 226 234 235 243 244 252 253 261 262 270 271 279 280 288 289 297 298 306 307 315 316 324 325 333 334 342 343 351 352 360 361 369 370 378 379 387 388 396 397 405 406 414 415 423 424 432 433 441 442 450 451 459 460 468 469 477 478 486 487 495 496 504 505 513 514 522 523 531 532 540 541 549 550 558 559 567 568 576 577 585 586 594 595 603 604 612 613 621 622 630 631 639 640 648 649 657 658 666 667 675 676 684 685 693 694 702 703 711 712 720 721 729 730 738 739 747 748 756 757 765 766 774 775 783 784 792 793 801 802 810 811 819 820 828 829 837 838 846 847 855 856 864 865 873 874 882 883 891 892 900 901 909 910 918 919 927 928 936 937 945 946 954 955 963 964 972 973 981 982 990 991 9991000 |
|||
DOG := 'Bernie'; |
|||
The Kaprekars in this range [ 1 9 45 55 99 297 703 999] are included |
|||
Trying 223 numbers instead of 1000 saves 77.70,%. |
|||
</pre> |
|||
PrintLn('There is just one dog named ' + dog);</syntaxhighlight> |
|||
=={{header|Go}}== |
|||
<syntaxhighlight lang=go>package main |
|||
Output: |
|||
import ( |
|||
<pre>There is just one dog named Bernie</pre> |
|||
"fmt" |
|||
=={{header|Déjà Vu}}== |
|||
"log" |
|||
<syntaxhighlight lang="dejavu">local :dog "Benjamin" |
|||
"strconv" |
|||
local :Dog "Samba" |
|||
) |
|||
local :DOG "Bernie" |
|||
!print( "There are three dogs named " dog ", " Dog " and " DOG "." )</syntaxhighlight> |
|||
{{out}} |
|||
<pre>There are three dogs named Benjamin, Samba and Bernie.</pre> |
|||
=={{header|EchoLisp}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
(define dog "Benjamin") |
|||
(define Dog "Samba") |
|||
(define DOG "Bernie") |
|||
(printf "The three dogs are named %a, %a and %a. " dog Dog DOG) |
|||
// A casting out nines algorithm. |
|||
The three dogs are named Benjamin, Samba and Bernie. |
|||
</syntaxhighlight> |
|||
=={{header|Elena}}== |
|||
In ELENA identifiers are case sensitive. |
|||
ELENA 4.x: |
|||
<syntaxhighlight lang="elena">import extensions; |
|||
public program() |
|||
// Quoting from: http://mathforum.org/library/drmath/view/55926.html |
|||
{ |
|||
/* |
|||
var dog := "Benjamin"; |
|||
First, for any number we can get a single digit, which I will call the |
|||
var Dog := "Samba"; |
|||
"check digit," by repeatedly adding the digits. That is, we add the |
|||
var DOG := "Bernie"; |
|||
digits of the number, then if there is more than one digit in the |
|||
console.printLineFormatted("The three dogs are named {0}, {1} and {2}", dog, Dog, DOG) |
|||
result we add its digits, and so on until there is only one digit |
|||
left. |
|||
... |
|||
You may notice that when you add the digits of 6395, if you just |
|||
ignore the 9, and the 6+3 = 9, you still end up with 5 as your check |
|||
digit. This is because any 9's make no difference in the result. |
|||
That's why the process is called "casting out" nines. Also, at any |
|||
step in the process, you can add digits, not just at the end: to do |
|||
8051647, I can say 8 + 5 = 13, which gives 4; plus 1 is 5, plus 6 is |
|||
11, which gives 2, plus 4 is 6, plus 7 is 13 which gives 4. I never |
|||
have to work with numbers bigger than 18. |
|||
*/ |
|||
// The twist is that co9Peterson returns a function to do casting out nines |
|||
// in any specified base from 2 to 36. |
|||
func co9Peterson(base int) (cob func(string) (byte, error), err error) { |
|||
if base < 2 || base > 36 { |
|||
return nil, fmt.Errorf("co9Peterson: %d invalid base", base) |
|||
} |
|||
// addDigits adds two digits in the specified base. |
|||
// People perfoming casting out nines by hand would usually have their |
|||
// addition facts memorized. In a program, a lookup table might be |
|||
// analogous, but we expediently use features of the programming language |
|||
// to add digits in the specified base. |
|||
addDigits := func(a, b byte) (string, error) { |
|||
ai, err := strconv.ParseInt(string(a), base, 64) |
|||
if err != nil { |
|||
return "", err |
|||
} |
|||
bi, err := strconv.ParseInt(string(b), base, 64) |
|||
if err != nil { |
|||
return "", err |
|||
} |
|||
return strconv.FormatInt(ai+bi, base), nil |
|||
} |
|||
// a '9' in the specified base. that is, the greatest digit. |
|||
s9 := strconv.FormatInt(int64(base-1), base) |
|||
b9 := s9[0] |
|||
// define result function. The result function may return an error |
|||
// if n is not a valid number in the specified base. |
|||
cob = func(n string) (r byte, err error) { |
|||
r = '0' |
|||
for i := 0; i < len(n); i++ { // for each digit of the number |
|||
d := n[i] |
|||
switch { |
|||
case d == b9: // if the digit is '9' of the base, cast it out |
|||
continue |
|||
// if the result so far is 0, the digit becomes the result |
|||
case r == '0': |
|||
r = d |
|||
continue |
|||
} |
|||
// otherwise, add the new digit to the result digit |
|||
s, err := addDigits(r, d) |
|||
if err != nil { |
|||
return 0, err |
|||
} |
|||
switch { |
|||
case s == s9: // if the sum is "9" of the base, cast it out |
|||
r = '0' |
|||
continue |
|||
// if the sum is a single digit, it becomes the result |
|||
case len(s) == 1: |
|||
r = s[0] |
|||
continue |
|||
} |
|||
// otherwise, reduce this two digit intermediate result before |
|||
// continuing. |
|||
r, err = cob(s) |
|||
if err != nil { |
|||
return 0, err |
|||
} |
|||
} |
|||
return |
|||
} |
|||
return |
|||
} |
|||
// Subset code required by task. Given a base and a range specified with |
|||
// beginning and ending number in that base, return candidate Kaprekar numbers |
|||
// based on the observation that k%(base-1) must equal (k*k)%(base-1). |
|||
// For the % operation, rather than the language built-in operator, use |
|||
// the method of casting out nines, which in fact implements %(base-1). |
|||
func subset(base int, begin, end string) (s []string, err error) { |
|||
// convert begin, end to native integer types for easier iteration |
|||
begin64, err := strconv.ParseInt(begin, base, 64) |
|||
if err != nil { |
|||
return nil, fmt.Errorf("subset begin: %v", err) |
|||
} |
|||
end64, err := strconv.ParseInt(end, base, 64) |
|||
if err != nil { |
|||
return nil, fmt.Errorf("subset end: %v", err) |
|||
} |
|||
// generate casting out nines function for specified base |
|||
cob, err := co9Peterson(base) |
|||
if err != nil { |
|||
return |
|||
} |
|||
for k := begin64; k <= end64; k++ { |
|||
ks := strconv.FormatInt(k, base) |
|||
rk, err := cob(ks) |
|||
if err != nil { // assertion |
|||
panic(err) // this would indicate a bug in subset |
|||
} |
|||
rk2, err := cob(strconv.FormatInt(k*k, base)) |
|||
if err != nil { // assertion |
|||
panic(err) // this would indicate a bug in subset |
|||
} |
|||
// test for candidate Kaprekar number |
|||
if rk == rk2 { |
|||
s = append(s, ks) |
|||
} |
|||
} |
|||
return |
|||
} |
|||
var testCases = []struct { |
|||
base int |
|||
begin, end string |
|||
kaprekar []string |
|||
}{ |
|||
{10, "1", "100", []string{"1", "9", "45", "55", "99"}}, |
|||
{17, "10", "gg", []string{"3d", "d4", "gg"}}, |
|||
} |
|||
func main() { |
|||
for _, tc := range testCases { |
|||
fmt.Printf("\nTest case base = %d, begin = %s, end = %s:\n", |
|||
tc.base, tc.begin, tc.end) |
|||
s, err := subset(tc.base, tc.begin, tc.end) |
|||
if err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
fmt.Println("Subset: ", s) |
|||
fmt.Println("Kaprekar:", tc.kaprekar) |
|||
sx := 0 |
|||
for _, k := range tc.kaprekar { |
|||
for { |
|||
if sx == len(s) { |
|||
fmt.Printf("Fail:", k, "not in subset") |
|||
return |
|||
} |
|||
if s[sx] == k { |
|||
sx++ |
|||
break |
|||
} |
|||
sx++ |
|||
} |
|||
} |
|||
fmt.Println("Valid subset.") |
|||
} |
|||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
The three dogs are named Benjamin, Samba and Bernie |
|||
Test case base = 10, begin = 1, end = 100: |
|||
</pre> |
|||
Subset: [1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100] |
|||
=={{header|Elixir}}== |
|||
Kaprekar: [1 9 45 55 99] |
|||
While Elixir's identifiers are case-sensitive, they generally must start with a lowercase letter. Capitalized identifiers are reserved for modules. |
|||
Valid subset. |
|||
<syntaxhighlight lang="elixir">dog = "Benjamin" |
|||
doG = "Samba" |
|||
dOG = "Bernie" |
|||
IO.puts "The three dogs are named #{dog}, #{doG} and #{dOG}."</syntaxhighlight> |
|||
{{out}} |
|||
Test case base = 17, begin = 10, end = gg: |
|||
<pre> |
|||
Subset: [10 1f 1g 2e 2f 3d 3e 4c 4d 5b 5c 6a 6b 79 7a 88 89 97 98 a6 a7 b5 b6 |
|||
The three dogs are named Benjamin, Samba and Bernie. |
|||
c4 c5 d3 d4 e2 e3 f1 f2 g0 g1 gg] |
|||
Kaprekar: [3d d4 gg] |
|||
Valid subset. |
|||
</pre> |
</pre> |
||
=={{header|Erlang}}== |
|||
Erlang variables are case sensitive but must start with an uppercase letter. |
|||
<syntaxhighlight lang="erlang"> |
|||
-module( case_sensitivity_of_identifiers ). |
|||
-export( [task/0] ). |
|||
=={{header|Haskell}}== |
|||
<syntaxhighlight lang=haskell>co9 n |
|||
| n <= 8 = n |
|||
| otherwise = co9 $ sum $ filter (/= 9) $ digits 10 n |
|||
task() -> |
|||
task2 = filter (\n -> co9 n == co9 (n ^ 2)) [1 .. 100] |
|||
catch dog = "Benjamin", % Function will crash without catch |
|||
Dog = "Samba", |
|||
DOG = "Bernie", |
|||
io:fwrite( "The three dogs are named ~s, ~s and ~s~n", [dog, Dog, DOG] ). |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
task3 k = filter (\n -> n `mod` k == n ^ 2 `mod` k) [1 .. 100]</syntaxhighlight> |
|||
<pre> |
|||
4> case_sensitivity_of_identifiers:task(). |
|||
The three dogs are named dog, Samba and Bernie |
|||
</pre> |
|||
=={{header|Euphoria}}== |
|||
{{works with|Euphoria|4.0.0}} |
|||
<syntaxhighlight lang="euphoria">-- These variables are all different |
|||
sequence dog = "Benjamin" |
|||
sequence Dog = "Samba" |
|||
sequence DOG = "Bernie" |
|||
printf( 1, "The three dogs are named %s, %s and %s\n", {dog, Dog, DOG} )</syntaxhighlight> |
|||
=={{header|F Sharp|F#}}== |
|||
F# is case-sensitive. |
|||
<syntaxhighlight lang="fsharp">let dog = "Benjamin" |
|||
let Dog = "Samba" |
|||
let DOG = "Bernie" |
|||
printfn "There are three dogs named %s, %s and %s" dog Dog DOG</syntaxhighlight> |
|||
=={{header|Factor}}== |
|||
Factor identifiers are case-sensitive. |
|||
<syntaxhighlight lang="factor">USING: formatting locals ; |
|||
IN: scratchpad |
|||
[let |
|||
"Benjamin" :> dog |
|||
"Samba" :> Dog |
|||
"Bernie" :> DOG |
|||
{ dog Dog DOG } "There are three dogs named %s, %s, and %s." vprintf |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
There are three dogs named Benjamin, Samba, and Bernie. |
|||
</pre> |
|||
=={{header|Forth}}== |
|||
<syntaxhighlight lang="forth">: DOG ." Benjamin" ; |
|||
: Dog ." Samba" ; |
|||
: dog ." Bernie" ; |
|||
: HOWMANYDOGS ." There is just one dog named " DOG ; |
|||
HOWMANYDOGS</syntaxhighlight> |
|||
{{out}} |
|||
<pre>There is just one dog named Bernie</pre> |
|||
=={{header|Fortran}}== |
|||
{{works with|Fortran|90 and later}} |
|||
Fortran is case insensitive, and so the three "dog" variants name the same variable - which therefore is multiply declared and will likely evoke a compiler complaint. |
|||
<syntaxhighlight lang="fortran">program Example |
|||
implicit none |
|||
character(8) :: dog, Dog, DOG |
|||
Auxillary function, returning digits of a number for given base |
|||
<syntaxhighlight lang=haskell>digits base = map (`mod` base) . takeWhile (> 0) . iterate (`div` base)</syntaxhighlight> |
|||
dog = "Benjamin" |
|||
or using unfolding: |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
if (dog == DOG) then |
|||
<syntaxhighlight lang=haskell>digits base = Data.List.unfoldr modDiv |
|||
write(*,*) "There is just one dog named ", dog |
|||
where modDiv 0 = Nothing |
|||
else |
|||
modDiv n = let (q, r) = (n `divMod` base) in Just (r, q)</syntaxhighlight> |
|||
write(*,*) "The three dogs are named ", dog, Dog, " and ", DOG |
|||
end if |
|||
'''Output''' |
|||
end program Example</syntaxhighlight> |
|||
<pre>λ> co9 232345 |
|||
Output: |
|||
1 |
|||
<pre> There is just one dog named Bernie</pre> |
|||
λ> co9 34234234 |
|||
=={{header|FreeBASIC}}== |
|||
7 |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
λ> co9 (232345 + 34234234) == co9 232345 + co9 34234234 |
|||
True |
|||
λ> co9 (232345 * 34234234) == co9 232345 * co9 34234234 |
|||
True |
|||
λ> task2 |
|||
[1,9,10,18,19,27,28,36,37,45,46,54,55,63,64,72,73,81,82,90,91,99,100] |
|||
λ> task2 == (task3 9) |
|||
True |
|||
λ> task3 16 |
|||
[1,16,17,32,33,48,49,64,65,80,81,96,97]</pre> |
|||
' FreeBASIC is case-insensitive |
|||
Finally it is possible to test usefull properties of <code>co9</code> with QuickCheck: |
|||
Dim dog As String |
|||
dog = "Benjamin" |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
Print "There is just one dog, named "; dog |
|||
Sleep</syntaxhighlight> |
|||
{{out}} |
|||
<pre>λ> :m Test.QuickCheck |
|||
<pre> |
|||
λ> quickCheck (\a -> a > 0 ==> co9 a == a `mod` 9) |
|||
There is just one dog, named Bernie |
|||
+++ OK, passed 100 tests. |
|||
</pre> |
|||
λ> quickCheck (\a b -> a > 0 && b > 0 ==> co9 (co9 a + co9 b) == co9 (a+b)) |
|||
=={{header|Frink}}== |
|||
+++ OK, passed 100 tests. |
|||
Frink is case-sensitive. |
|||
λ> quickCheck (\a b -> a > 0 && b > 0 ==> co9 (co9 a * co9 b) == co9 (a*b)) |
|||
<syntaxhighlight lang="frink">dog = "Benjamin" |
|||
+++ OK, passed 100 tests.</pre> |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
println["There are three dogs named $dog, $Dog and $DOG"]</syntaxhighlight> |
|||
=={{header|Gambas}}== |
|||
'''[https://gambas-playground.proko.eu/?gist=fed58074944b894f5d4cfb8e16c6819a Click this link to run this code]''' |
|||
Gambas in case insensitive |
|||
=={{header|J}}== |
|||
<syntaxhighlight lang="gambas">Public Sub Main() |
|||
This is an implementation of: "given two numbers which mark the beginning and end of a range of integers, and another number which denotes an integer base, return numbers from within the range where the number is equal (modulo the base minus 1) to its square". At the time of this writing, this task is a draft task and this description does not precisely match the task description on this page. Eventually, either the task description will change to match this implementation (which means this paragraph should be removed) or the task description will change to conflict with this implementation (so this entire section should be re-written). |
|||
Dim dog As String |
|||
<syntaxhighlight lang=J>castout=: 1 :0 |
|||
[: (#~ ] =&((m-1)&|) *:) <. + [: i. (+*)@-~ |
|||
)</syntaxhighlight> |
|||
Example use: |
|||
<syntaxhighlight lang=J> 0 (10 castout) 100 |
|||
0 1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100</syntaxhighlight> |
|||
Alternate implementation: |
|||
<syntaxhighlight lang=J>castout=: 1 :0 |
|||
[: (#~ 0 = (m-1) | 0 _1 1&p.) <. + [: i. (+*)@-~ |
|||
)</syntaxhighlight> |
|||
Note that about half of the code here is the code that implements "range of numbers". If we factor that out, and represent the desired values directly the code becomes much simpler: |
|||
<syntaxhighlight lang=J> (#~ 0=9|0 _1 1&p.) i.101 |
|||
0 1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100 |
|||
(#~ ] =&(9&|) *:) i. 101 |
|||
0 1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100</syntaxhighlight> |
|||
And, of course, we can name parts of these expressions. For example: |
|||
<syntaxhighlight lang=J> (#~ ] =&(co9=: 9&|) *:) i. 101 |
|||
0 1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100</syntaxhighlight> |
|||
Or, if you prefer: |
|||
<syntaxhighlight lang=J>co9=: 9&| |
|||
(#~ ] =&co9 *:) i. 101 |
|||
0 1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100</syntaxhighlight> |
|||
Dog = "Benjamin" |
|||
=={{header|Java}}== |
|||
DOG = "Samba" |
|||
{{trans|D}} |
|||
dog = "Bernie" |
|||
{{works with|Java|8}} |
|||
Print "There is just one dog, named "; dog |
|||
<syntaxhighlight lang=java>import java.util.*; |
|||
import java.util.stream.IntStream; |
|||
End</syntaxhighlight> |
|||
public class CastingOutNines { |
|||
Output: |
|||
<pre> |
|||
There is just one dog, named Bernie |
|||
</pre> |
|||
=={{header|GAP}}== |
|||
<syntaxhighlight lang="gap"># GAP is case sensitive |
|||
ThreeDogs := function() |
|||
local dog, Dog, DOG; |
|||
dog := "Benjamin"; |
|||
Dog := "Samba"; |
|||
DOG := "Bernie"; |
|||
if dog = DOG then |
|||
Print("There is just one dog named ", dog, "\n"); |
|||
else |
|||
Print("The three dogs are named ", dog, ", ", Dog, " and ", DOG, "\n"); |
|||
fi; |
|||
end; |
|||
ThreeDogs(); |
|||
public static void main(String[] args) { |
|||
# The three dogs are named Benjamin, Samba and Bernie</syntaxhighlight> |
|||
System.out.println(castOut(16, 1, 255)); |
|||
=={{header|Go}}== |
|||
System.out.println(castOut(10, 1, 99)); |
|||
Go is case sensitive. Further, visibility depends on case. See the Go entry under the [[Scope_modifiers#Go|Scope modifiers]] task. |
|||
System.out.println(castOut(17, 1, 288)); |
|||
<syntaxhighlight lang="go">package dogs |
|||
} |
|||
import "fmt" |
|||
static List<Integer> castOut(int base, int start, int end) { |
|||
int[] ran = IntStream |
|||
.range(0, base - 1) |
|||
.filter(x -> x % (base - 1) == (x * x) % (base - 1)) |
|||
.toArray(); |
|||
// Three variables, three different names. |
|||
int x = start / (base - 1); |
|||
// (It wouldn't compile if the compiler saw the variable names as the same.) |
|||
var dog = "Salt" |
|||
var Dog = "Pepper" |
|||
var DOG = "Mustard" |
|||
func PackageSees() map[*string]int { |
|||
List<Integer> result = new ArrayList<>(); |
|||
// Print dogs visible from here. |
|||
fmt.Println("Package sees:", dog, Dog, DOG) |
|||
for (int n : ran) { |
|||
// Return addresses of the variables visible from here. |
|||
int k = (base - 1) * x + n; |
|||
// The point of putting them in a map is that maps store only |
|||
// unique keys, so it will end up with three items only if |
|||
// the variables really represent different places in memory. |
|||
if (k > end) |
|||
return map[*string]int{&dog: 1, &Dog: 1, &DOG: 1} |
|||
return result; |
|||
result.add(k); |
|||
} |
|||
x++; |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
<syntaxhighlight lang="go">package main |
|||
import ( |
|||
<pre>[1, 6, 10, 15, 16, 21, 25, 30, 31, 36, 40, 45, 46, 51, 55, 60, 61, 66, |
|||
. "dogs" |
|||
70, 75, 76, 81, 85, 90, 91, 96, 100, 105, 106, 111, 115, 120, 121, 126, 130, |
|||
"fmt" |
|||
135, 136, 141, 145, 150, 151, 156, 160, 165, 166, 171, 175, 180, 181, 186, |
|||
) |
|||
190, 195, 196, 201, 205, 210, 211, 216, 220, 225, 226, 231, 235, 240, 241, 246, 250, 255] |
|||
[1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, 81, 82, 90, 91, 99] |
|||
[1, 16, 17, 32, 33, 48, 49, 64, 65, 80, 81, 96, 97, 112, 113, 128, 129, 144, 145, 160, |
|||
161, 176, 177, 192, 193, 208, 209, 224, 225, 240, 241, 256, 257, 272, 273, 288]</pre> |
|||
func main() { |
|||
=={{header|JavaScript}}== |
|||
// with the dogs package imported, there are three dogs. |
|||
===ES5=== |
|||
d := PackageSees() |
|||
Assuming the context of a web page: |
|||
fmt.Println("There are", len(d), "dogs.\n") |
|||
<syntaxhighlight lang=JavaScript>function main(s, e, bs, pbs) { |
|||
bs = bs || 10; |
|||
pbs = pbs || 10 |
|||
document.write('start:', toString(s), ' end:', toString(e), |
|||
' base:', bs, ' printBase:', pbs) |
|||
document.write('<br>castOutNine: '); |
|||
castOutNine() |
|||
document.write('<br>kaprekar: '); |
|||
kaprekar() |
|||
document.write('<br><br>') |
|||
// Declaration of new variable dog. It lives in this package, main. |
|||
function castOutNine() { |
|||
dog := "Benjamin" |
|||
for (var n = s, k = 0, bsm1 = bs - 1; n <= e; n += 1) |
|||
d = PackageSees() |
|||
if (n % bsm1 == (n * n) % bsm1) k += 1, |
|||
fmt.Println("Main sees: ", dog, Dog, DOG) |
|||
document.write(toString(n), ' ') |
|||
// Four dogs now. two of the three visible from here are the |
|||
document.write('<br>trying ', k, ' numbers instead of ', n = e - s + 1, |
|||
// the same as ones in the dogs package. |
|||
' numbers saves ', (100 - k / n * 100) |
|||
d[&dog] = 1 |
|||
.toFixed(3), '%') |
|||
d[&Dog] = 1 |
|||
d[&DOG] = 1 |
|||
fmt.Println("There are", len(d), "dogs.\n") |
|||
// Not a declaration, just an assigment. This assigns a new value to |
|||
function kaprekar() { |
|||
// the variable Dog declared in the package. Dog is visible because |
|||
// it begins with an upper case letter. |
|||
if (isKaprekar(n)) document.write(toString(n), ' ') |
|||
Dog = "Samba" |
|||
// same four dogs, same three visible, one just has a new name. |
|||
d = PackageSees() |
|||
fmt.Println("Main sees: ", dog, Dog, DOG) |
|||
d[&dog] = 1 |
|||
d[&Dog] = 1 |
|||
d[&DOG] = 1 |
|||
fmt.Println("There are", len(d), "dogs.\n") |
|||
// Of course you can still declare a variable if you want to. This |
|||
function isKaprekar(n) { |
|||
// declares a new variable, shadowing DOG in the package and rendering |
|||
if (n < 1) return false |
|||
// it inaccessable even though it begins with an upper case letter. |
|||
if (n == 1) return true |
|||
var DOG = "Bernie" |
|||
// five dogs now. three visible from here. |
|||
d = PackageSees() |
|||
for (var i = 1, e = s.length; i < e; i += 1) { |
|||
fmt.Println("Main sees: ", dog, Dog, DOG) |
|||
var a = parseInt(s.substr(0, i), bs) |
|||
d[&dog] = 1 |
|||
var b = parseInt(s.substr(i), bs) |
|||
d[&Dog] = 1 |
|||
if (b && a + b == n) return true |
|||
d[&DOG] = 1 |
|||
fmt.Println("There are", len(d), "dogs.") |
|||
return false |
|||
}</syntaxhighlight> |
|||
} |
|||
{{out}} |
|||
} |
|||
<pre> |
|||
Package sees: Salt Pepper Mustard |
|||
There are 3 dogs. |
|||
Package sees: Salt Pepper Mustard |
|||
function toString(n) { |
|||
Main sees: Benjamin Pepper Mustard |
|||
return n.toString(pbs) |
|||
There are 4 dogs. |
|||
.toUpperCase() |
|||
} |
|||
} |
|||
main(1, 10 * 10 - 1) |
|||
main(1, 16 * 16 - 1, 16) |
|||
main(1, 17 * 17 - 1, 17) |
|||
main(parseInt('10', 17), parseInt('gg', 17), 17, 17)</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>start:1 end:99 base:10 printBase:10 |
|||
castOutNine: 1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
trying 22 numbers instead of 99 numbers saves 77.778% |
|||
kaprekar: 1 9 45 55 99 |
|||
Package sees: Salt Samba Mustard |
|||
start:1 end:255 base:16 printBase:10 |
|||
Main sees: Benjamin Samba Mustard |
|||
castOutNine: 1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 |
|||
There are 4 dogs. |
|||
141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255 |
|||
trying 68 numbers instead of 255 numbers saves 73.333% |
|||
kaprekar: 1 6 10 15 51 85 91 120 136 171 205 255 |
|||
Package sees: Salt Samba Mustard |
|||
start:1 end:288 base:17 printBase:10 |
|||
Main sees: Benjamin Samba Bernie |
|||
castOutNine: 1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 192 193 208 209 224 225 240 241 256 257 272 273 288 |
|||
There are 5 dogs. |
|||
trying 36 numbers instead of 288 numbers saves 87.500% |
|||
</pre> |
|||
kaprekar: 1 16 64 225 288 |
|||
=={{header|Groovy}}== |
|||
Solution: |
|||
<syntaxhighlight lang="groovy">def dog = "Benjamin", Dog = "Samba", DOG = "Bernie" |
|||
println (dog == DOG ? "There is one dog named ${dog}" : "There are three dogs named ${dog}, ${Dog} and ${DOG}.")</syntaxhighlight> |
|||
Output: |
|||
start:10 end:GG base:17 printBase:17 |
|||
<pre>There are three dogs named Benjamin, Samba and Bernie.</pre> |
|||
castOutNine: 10 1F 1G 2E 2F 3D 3E 4C 4D 5B 5C 6A 6B 79 7A 88 89 97 98 A6 A7 B5 B6 C4 C5 D3 D4 E2 E3 F1 F2 G0 G1 GG |
|||
=={{header|Haskell}}== |
|||
trying 34 numbers instead of 272 numbers saves 87.500% |
|||
Identifiers are case sensitive in Haskell, but must start with a lower case letter. |
|||
kaprekar: 3D D4 GG </pre> |
|||
<syntaxhighlight lang="haskell">import Text.Printf |
|||
===ES6=== |
|||
{{Trans|Haskell}} |
|||
<syntaxhighlight lang=JavaScript>(() => { |
|||
'use strict'; |
|||
main = printf "The three dogs are named %s, %s and %s.\n" dog dOG dOg |
|||
// co9 :: Int -> Int |
|||
where dog = "Benjamin" |
|||
dOG = "Samba" |
|||
dOg = "Bernie"</syntaxhighlight> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
|||
.reduce((a, x) => x !== 9 ? a + x : a, 0) |
|||
The program below demonstrates the three dog task. All variants of Icon/Unicon have case sensitive variable names. But if one wasn't this would find it. |
|||
); |
|||
<syntaxhighlight lang="icon">procedure main() |
|||
dog := "Benjamin" |
|||
// GENERIC FUNCTIONS |
|||
Dog := "Samba" |
|||
DOG := "Bernie" |
|||
if dog == DOG then |
|||
write("There is just one dog named ", dog,".") |
|||
else |
|||
write("The three dogs are named ", dog, ", ", Dog, " and ", DOG, ".") |
|||
end</syntaxhighlight> |
|||
// digits :: Int -> Int -> [Int] |
|||
=={{header|J}}== |
|||
const digits = (base, n) => { |
|||
<syntaxhighlight lang="j"> NB. These variables are all different |
|||
if (n < base) return [n]; |
|||
dog=: 'Benjamin' |
|||
const [q, r] = quotRem(n, base); |
|||
Dog=: 'Samba' |
|||
return [r].concat(digits(base, q)); |
|||
DOG=: 'Bernie' |
|||
'The three dogs are named ',dog,', ',Dog,', and ',DOG |
|||
The three dogs are named Benjamin, Samba, and Bernie </syntaxhighlight> |
|||
=={{header|Java}}== |
|||
<syntaxhighlight lang="java">String dog = "Benjamin"; |
|||
String Dog = "Samba"; //in general, identifiers that start with capital letters are class names |
|||
String DOG = "Bernie"; //in general, identifiers in all caps are constants |
|||
//the conventions listed in comments here are not enforced by the language |
|||
System.out.println("There are three dogs named " + dog + ", " + Dog + ", and " + DOG + "'");</syntaxhighlight> |
|||
=={{header|JavaScript}}== |
|||
Javascript is case sensitive. |
|||
<syntaxhighlight lang="javascript">var dog = "Benjamin"; |
|||
var Dog = "Samba"; |
|||
var DOG = "Bernie"; |
|||
document.write("The three dogs are named " + dog + ", " + Dog + ", and " + DOG + ".");</syntaxhighlight> |
|||
=={{header|jq}}== |
|||
jq identifiers are case-sensitive. |
|||
'''Function parameters''': |
|||
// quotRem :: Integral a => a -> a -> (a, a) |
|||
<syntaxhighlight lang="jq">def task(dog; Dog; DOG): |
|||
const quotRem = (m, n) => [Math.floor(m / n), m % n]; |
|||
"The three dogs are named \(dog), \(Dog), and \(DOG)." ; |
|||
task("Benjamin"; "Samba"; "Bernie")</syntaxhighlight> |
|||
// range :: Int -> Int -> [Int] |
|||
const range = (m, n) => |
|||
Array.from({ |
|||
length: Math.floor(n - m) + 1 |
|||
}, (_, i) => m + i); |
|||
// squared :: Num a => a -> a |
|||
const squared = n => Math.pow(n, 2); |
|||
// show :: a -> String |
|||
const show = x => JSON.stringify(x, null, 2); |
|||
// TESTS |
|||
return show({ |
|||
test1: co9(232345), //-> 1 |
|||
test2: co9(34234234), //-> 7 |
|||
test3: co9(232345 + 34234234) === co9(232345) + co9(34234234), //-> true |
|||
test4: co9(232345 * 34234234) === co9(232345) * co9(34234234), //-> true, |
|||
task2: range(1, 100) |
|||
.filter(n => co9(n) === co9(squared(n))), |
|||
task3: (k => range(1, 100) |
|||
.filter(n => (n % k) === (squared(n) % k)))(16) |
|||
}); |
|||
})();</syntaxhighlight> |
|||
{{Out}} |
{{Out}} |
||
$ jq -n -f Case-sensitivity.jq |
|||
<pre>{ |
|||
"The three dogs are named Benjamin, Samba, and Bernie." |
|||
"test1": 1, |
|||
"test2": 7, |
|||
"test3": true, |
|||
"test4": true, |
|||
"task2": [ |
|||
1, |
|||
9, |
|||
10, |
|||
18, |
|||
19, |
|||
27, |
|||
28, |
|||
36, |
|||
37, |
|||
45, |
|||
46, |
|||
54, |
|||
55, |
|||
63, |
|||
64, |
|||
72, |
|||
73, |
|||
81, |
|||
82, |
|||
90, |
|||
91, |
|||
99, |
|||
100 |
|||
], |
|||
"task3": [ |
|||
1, |
|||
16, |
|||
17, |
|||
32, |
|||
33, |
|||
48, |
|||
49, |
|||
64, |
|||
65, |
|||
80, |
|||
81, |
|||
96, |
|||
97 |
|||
] |
|||
}</pre> |
|||
'''Variable names''': |
|||
=={{header|jq}}== |
|||
<syntaxhighlight lang="jq">"Benjamin" as $dog | "Samba" as $Dog | "Bernie" as $DOG |
|||
{{ works with|jq|1.4}} |
|||
| "The three dogs are named \($dog), \($Dog), and \($DOG)."</syntaxhighlight> |
|||
{{out}} |
|||
As above. |
|||
=={{header|Julia}}== |
|||
{{works with|Julia|0.6}} |
|||
Variable names are case sensitive. |
|||
<syntaxhighlight lang="julia">dog, Dog, DOG = "Benjamin", "Samba", "Bernie" |
|||
if dog === Dog |
|||
In the following, the filter is_kaprekar as defined at [[Kaprekar_numbers#jq]] is used. |
|||
println("There is only one dog, ", DOG) |
|||
Since it is only defined for decimals, this section is correspondingly restricted. |
|||
else |
|||
println("The three dogs are: ", dog, ", ", Dog, " and ", DOG) |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
'''Definition of co9''': |
|||
<pre>The three dogs are: Benjamin, Samba and Bernie</pre> |
|||
<syntaxhighlight lang=jq>def co9: |
|||
def digits: tostring | explode | map(. - 48); # "0" is 48 |
|||
if . == 9 then 0 |
|||
elif 0 <= . and . <= 8 then . |
|||
else digits | add | co9 |
|||
end;</syntaxhighlight> |
|||
Conventionally, variable names should be all lower case. Type and Macro names should be capitalized. |
|||
For convenience, we also define a function to check whether co9(i) equals co9(i*i) |
|||
=={{header|K}}== |
|||
for a given integer, i: |
|||
<syntaxhighlight lang= |
<syntaxhighlight lang="k"> |
||
dog: "Benjamin" |
|||
Dog: "Samba" |
|||
DOG: "Bernie" |
|||
"There are three dogs named ",dog,", ",Dog," and ",DOG |
|||
"There are three dogs named Benjamin, Samba and Bernie" |
|||
</syntaxhighlight> |
|||
=={{header|Kotlin}}== |
|||
Kotlin is case-sensitive though (as in Java) the convention is for local variable names to begin with a lower case letter. The second and third identifiers would therefore be unlikely to be used in practice. |
|||
<syntaxhighlight lang="scala">fun main(args: Array<String>) { |
|||
val dog = "Benjamin" |
|||
val Dog = "Samba" |
|||
val DOG = "Bernie" |
|||
println("The three dogs are named $dog, $Dog and $DOG") |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
'''Example''': |
|||
<pre> |
|||
The three dogs are named Benjamin, Samba and Bernie |
|||
</pre> |
|||
=={{header|Lasso}}== |
|||
Lasso is not case sensitive for names |
|||
<syntaxhighlight lang="lasso"> |
|||
local(dog = 'Benjamin') |
|||
local(Dog = 'Samba') |
|||
local(DOG = 'Bernie') |
|||
stdoutnl('There is just one dog named ' + #dog) |
|||
Integers in 1 .. 100 satisfying co9(i) == co9(i*i): |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre>There is just one dog named Bernie</pre> |
|||
Same with string comparisons. (Lasso maps can only contain unique keys) |
|||
<syntaxhighlight lang=jq>[range (1;101) | select( co9_equals_co9_squared )</syntaxhighlight> |
|||
<syntaxhighlight lang="lasso"> |
|||
produces: |
|||
local(dogs = map( |
|||
[1,9,10,18,19,27,28,36,37,45,46,54,55,63,64,72,73,81,82,90,91,99,100] |
|||
'dog' = 'Benjamin', |
|||
'Dog' = 'Samba', |
|||
'DOG' = 'Bernie' |
|||
)) |
|||
stdoutnl(#dogs -> size)</syntaxhighlight> |
|||
Output: |
|||
<pre>1</pre> |
|||
To get case sensitivity we need to use bytes |
|||
'''Verification''': |
|||
<syntaxhighlight lang="lasso"> |
|||
local(dogs = map( |
|||
bytes('dog') = 'Benjamin', |
|||
bytes('Dog') = 'Samba', |
|||
bytes('DOG') = 'Bernie' |
|||
)) |
|||
stdoutnl(#dogs -> size) |
|||
One way to verify that the Kaprekar numbers satisfy the |
|||
co9_equals_co9_squared condition is by inspection. For the range 1..100 considered above, we have: |
|||
stdoutnl(#dogs -> find(bytes('Dog')))</syntaxhighlight> |
|||
Output: |
|||
<pre>3 |
|||
Samba </pre> |
|||
=={{header|Liberty BASIC}}== |
|||
NB the IDE warns you that there are similar variables named dog$, Dog$ & DOG$ |
|||
<syntaxhighlight lang="lb"> |
|||
dog$ = "Benjamin" |
|||
Dog$ = "Samba" |
|||
DOG$ = "Bernie" |
|||
print "The three dogs are "; dog$; ", "; Dog$; " and "; DOG$; "." |
|||
end |
|||
[1,9,45,55,99] |
|||
</syntaxhighlight> |
|||
The three dogs are Benjamin, Samba and Bernie. |
|||
=={{header|Lua}}== |
|||
<syntaxhighlight lang="lua">dog = "Benjamin" |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
print( "There are three dogs named "..dog..", "..Dog.." and "..DOG.."." )</syntaxhighlight> |
|||
To check the condition programmatically for a given range of integers, we can |
|||
<pre>There are three dogs named Benjamin, Samba and Bernie.</pre> |
|||
define a function which will emit any exceptions, e.g. |
|||
=={{header|M2000 Interpreter}}== |
|||
<syntaxhighlight lang=jq>def verify: |
|||
Labels are case sensitive, but identifiers are not case sensitive. |
|||
range(1; .) |
|||
Keys in Inventory are case sensitive |
|||
| select(is_kaprekar and (co9_equals_co9_squared | not));</syntaxhighlight> |
|||
Types in Enumeration are case sensitive, identifiers are not case sensitive. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
For example, running (1000 | verify) produces an empty stream. |
|||
MoDuLe CheckIT { |
|||
\\ keys as case sensitive if they are strings |
|||
Inventory A= "Dog":=1, "dog":=2,"DOG":="Hello", 100:="Dog" |
|||
Print A("Dog"), A("dog"), A$("DOG"), A$(100) |
|||
\\ Enumeration get type as defined (same case) |
|||
Enum Dogs {Benjamin, Samba, Bernie} |
|||
Print Type$(Bernie)="Dogs" |
|||
Print Type$(DOGS)="Dogs" |
|||
m=BenJamiN |
|||
m++ |
|||
Print Eval$(m)="Samba" ' same case as defined |
|||
DoG$="Benjamin" |
|||
DOG$="Samba" |
|||
doG$="Bernie" |
|||
PrinT "There is just one dog named "+Dog$+"." |
|||
goto Dog |
|||
dog: |
|||
Print "dog" |
|||
Exit |
|||
Dog: |
|||
Print "Dog" |
|||
GoTo dog |
|||
} |
|||
Checkit |
|||
</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
<syntaxhighlight lang="text">> dog, Dog, DOG := "Benjamin", "Samba", "Bernie": |
|||
> if nops( { dog, Dog, DOG } ) = 3 then |
|||
> printf( "There are three dogs named %s, %s and %s.\n", dog, Dog, DOG ) |
|||
> elif nops( { dog, Dog, DOG } ) = 2 then |
|||
> printf( "WTF? There are two dogs named %s and %s.\n", op( { dog, Dog, DOG } ) ) |
|||
> else |
|||
> printf( "There is one dog named %s.\n", dog ) |
|||
> end if: |
|||
There are three dogs named Benjamin, Samba and Bernie.</syntaxhighlight> |
|||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="mathematica">dog = "Benjamin"; Dog = "Samba"; DOG = "Bernie"; |
|||
"The three dogs are named "<> dog <>", "<> Dog <>" and "<> DOG |
|||
-> "The three dogs are named Benjamin, Samba and Bernie"</syntaxhighlight> |
|||
'''Proportion of integers in 1 .. n satisfying the mod (b-1) condition''': |
|||
=={{header|MATLAB}} / {{header|Octave}}== |
|||
<syntaxhighlight lang="matlab"> dog = 'Benjamin'; |
|||
For a given base, "b", the following function computes the |
|||
Dog = 'Samba'; |
|||
proportion of integers, i, in 1 .. n such that i % (b-1) == (i*i) % (b-1): |
|||
DOG = 'Bernie'; |
|||
printf('There are three dogs %s, %s, %s.\n',dog, Dog, DOG); </syntaxhighlight> |
|||
<syntaxhighlight lang=jq>def proportion(base): |
|||
def count(stream): reduce stream as $i (0; . + 1); |
|||
. as $n |
|||
| (base - 1) as $b |
|||
| count( range(1; 1+$n) | select( . % $b == (.*.) % $b) ) / $n ;</syntaxhighlight> |
|||
For example: |
|||
Output |
|||
(10, 100, 1000, 10000, 100000) | proportion(16) |
|||
<pre> There are three dogs Benjamin, Samba, Bernie. </pre> |
|||
produces: |
|||
=={{header|Maxima}}== |
|||
<syntaxhighlight lang=sh>0.3 |
|||
<syntaxhighlight lang="maxima">/* Maxima is case sensitive */ |
|||
0.27 |
|||
a: 1$ |
|||
0.267 |
|||
A: 2$ |
|||
0.2667 |
|||
0.26667</syntaxhighlight> |
|||
is(a = A); |
|||
=={{header|Julia}}== |
|||
<syntaxhighlight |
false</syntaxhighlight> |
||
=={{header|min}}== |
|||
1<=x<=8 ? x : |
|||
{{works with|min|0.19.3}} |
|||
co9(sum(digits(x)))</syntaxhighlight> |
|||
min's symbols are case sensitive. |
|||
iskaprekar is defined in the task |
|||
<syntaxhighlight lang="min">"Benjamin" :dog |
|||
[[Kaprekar_numbers#Julia]]. |
|||
"Samba" :Dog |
|||
{{Out}} |
|||
"Bernie" :DOG |
|||
<pre>julia> show(filter(x->co9(x)==co9(x^2), 1:100)) |
|||
[1,9,10,18,19,27,28,36,37,45,46,54,55,63,64,72,73,81,82,90,91,99,100] |
|||
julia> show(filter(iskaprekar, 1:100)) |
|||
[1,9,45,55,99] |
|||
julia> show(filter(x->x%15 == (x^2)%15, 1:100)) # base 16 |
|||
[1,6,10,15,16,21,25,30,31,36,40,45,46,51,55,60,61,66,70,75,76,81,85,90,91,96,100]</pre> |
|||
=={{header|Kotlin}}== |
|||
{{trans|D}} |
|||
<syntaxhighlight lang=scala>// version 1.1.3 |
|||
fun castOut(base: Int, start: Int, end: Int): List<Int> { |
|||
val b = base - 1 |
|||
val ran = (0 until b).filter { it % b == (it * it) % b } |
|||
var x = start / b |
|||
val result = mutableListOf<Int>() |
|||
while (true) { |
|||
for (n in ran) { |
|||
val k = b * x + n |
|||
if (k < start) continue |
|||
if (k > end) return result |
|||
result.add(k) |
|||
} |
|||
x++ |
|||
} |
|||
} |
|||
fun main(args: Array<String>) { |
|||
println(castOut(16, 1, 255)) |
|||
println() |
|||
println(castOut(10, 1, 99)) |
|||
println() |
|||
println(castOut(17, 1, 288)) |
|||
}</syntaxhighlight> |
|||
"There are three dogs named $1, $2, and $3." (dog Dog DOG)=> % print</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
There are three dogs named Benjamin, Samba, and Bernie. |
|||
[1, 6, 10, 15, 16, 21, 25, 30, 31, 36, 40, 45, 46, 51, 55, 60, 61, 66, 70, 75, 76, 81, 85, 90, 91, 96, 100, 105, 106, 111, 115, 120, 121, 126, 130, 135, 136, 141, 145, 150, 151, 156, 160, 165, 166, 171, 175, 180, 181, 186, 190, 195, 196, 201, 205, 210, 211, 216, 220, 225, 226, 231, 235, 240, 241, 246, 250, 255] |
|||
</pre> |
|||
=={{header|MiniScript}}== |
|||
<syntaxhighlight lang="miniscript">dog = "Benjamin" |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
print "There are three dogs named " + dog + ", " + Dog + " and " + DOG</syntaxhighlight> |
|||
[1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, 81, 82, 90, 91, 99] |
|||
=={{header|Modula-2}}== |
|||
<syntaxhighlight lang="modula2">MODULE dog; |
|||
IMPORT InOut; |
|||
[1, 16, 17, 32, 33, 48, 49, 64, 65, 80, 81, 96, 97, 112, 113, 128, 129, 144, 145, 160, 161, 176, 177, 192, 193, 208, 209, 224, 225, 240, 241, 256, 257, 272, 273, 288] |
|||
</pre> |
|||
TYPE String = ARRAY [0..31] OF CHAR; |
|||
=={{header|Lua}}== |
|||
{{trans|C}} |
|||
<syntaxhighlight lang=lua>local N = 2 |
|||
local base = 10 |
|||
local c1 = 0 |
|||
local c2 = 0 |
|||
VAR dog, Dog, DOG : String; |
|||
c1 = c1 + 1 |
|||
if k % (base - 1) == (k * k) % (base - 1) then |
|||
c2 = c2 + 1 |
|||
io.write(k .. ' ') |
|||
end |
|||
end |
|||
(* No compiler error, so the rest is simple *) |
|||
print() |
|||
print(string.format("Trying %d numbers instead of %d numbers saves %f%%", c2, c1, 100.0 - 100.0 * c2 / c1))</syntaxhighlight> |
|||
{{out}} |
|||
<pre>1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
Trying 22 numbers instead of 99 numbers saves 77.777778%</pre> |
|||
BEGIN |
|||
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
|||
InOut.WriteString ("Three happy dogs."); |
|||
Task 1: Simple referenced implementation that handles any base: |
|||
InOut.WriteLn |
|||
<syntaxhighlight lang=mathematica>Co9[n_, b_: 10] := |
|||
END dog.</syntaxhighlight> |
|||
With[{ans = FixedPoint[Total@IntegerDigits[#, b] &, n]}, |
|||
=={{header|Nanoquery}}== |
|||
If[ans == b - 1, 0, ans]];</syntaxhighlight> |
|||
<syntaxhighlight lang="nanoquery">dog = "Benjamin" |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
print format("The three dogs are named %s, %s, and %s.\n", dog, Dog, DOG)</syntaxhighlight> |
|||
{{out|Task 1 output}} |
|||
{{out}} |
|||
<syntaxhighlight lang=mathematica>Co9 /@ (vals = {1235, 2345, 4753}) |
|||
<pre>The three dogs are named Benjamin, Samba, and Bernie.</pre> |
|||
{2, 5, 1} |
|||
=={{header|Nemerle}}== |
|||
<syntaxhighlight lang="nemerle">def dog = "Benjamin"; |
|||
def Dog = "Samba"; |
|||
def DOG = "Bernie"; |
|||
WriteLine($"The three dogs are named $dog, $Dog, and $DOG");</syntaxhighlight> |
|||
=={{header|NESL}}== |
|||
NESL is completely case-insensitive. |
|||
<syntaxhighlight lang="nesl">dog = "Benjamin"; |
|||
Dog = "Samba"; |
|||
DOG = "Bernie"; |
|||
"There is just one dog, named " ++ dog;</syntaxhighlight> |
|||
{{out}} |
|||
<pre>it = "There is just one dog, named Bernie" : [char]</pre> |
|||
=={{header|NetRexx}}== |
|||
NetRexx is not case sensitive: |
|||
<syntaxhighlight lang="netrexx">/* NetRexx */ |
|||
options replace format comments java crossref symbols nobinary |
|||
dog = "Benjamin"; |
|||
Total[Co9 /@ vals] == Co9[Total[vals]] |
|||
Dog = "Samba"; |
|||
True</syntaxhighlight> |
|||
DOG = "Bernie"; |
|||
if dog == Dog & Dog == DOG & dog == DOG then do |
|||
Task 2: |
|||
say 'There is just one dog named' dog'.' |
|||
<syntaxhighlight lang=mathematica>task2 = Select[Range@100, Co9[#] == Co9[#^2] &] </syntaxhighlight> |
|||
end |
|||
else do |
|||
say 'The three dogs are named' dog',' Dog 'and' DOG'.' |
|||
end |
|||
return |
|||
{{out|Task 2 output}} |
|||
</syntaxhighlight> |
|||
'''Output:''' |
|||
<pre> |
<pre> |
||
There is just one dog named Bernie. |
|||
{1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, 81, 82, 90, 91, 99, 100} |
|||
</pre> |
</pre> |
||
Task 3: |
|||
Defines the efficient co9 using Mod. |
|||
<syntaxhighlight lang=mathematica>Co9eff[n_, b_: 10] := Mod[n, b - 1]; </syntaxhighlight> |
|||
{{out|Task 3 output}} |
|||
Testing bases 10 and 17 |
|||
<syntaxhighlight lang=mathematica>task2 == Select[Range@100, Co9eff[#] == Co9eff[#^2] &] |
|||
True |
|||
Select[Range@100, Co9eff[#, 17] == Co9eff[#^2, 17] &] |
|||
{1, 16, 17, 32, 33, 48, 49, 64, 65, 80, 81, 96, 97}</syntaxhighlight> |
|||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
Nim has peculiar rules regarding case and style sensitivity: |
|||
<syntaxhighlight lang=nim>import sequtils |
|||
:– it is mainly a case insensitive language; |
|||
:– but keywords are all in lowercase; |
|||
:– and the first letter of an identifier is case sensitive; |
|||
:– moreover, underline is ignored in identifiers (style insensitivity). |
|||
With these rules, we don’t get one dog or three dogs: we get two dogs! |
|||
iterator castOut(base = 10, start = 1, ending = 999_999): int = |
|||
var ran: seq[int] = @[] |
|||
for y in 0 ..< base-1: |
|||
if y mod (base - 1) == (y*y) mod (base - 1): |
|||
ran.add(y) |
|||
<syntaxhighlight lang="nim">var dog, Dog: string |
|||
var x = start div (base - 1) |
|||
(dog, Dog, DOG) = ("Benjamin", "Samba", "Bernie") |
|||
var y = start mod (base - 1) |
|||
if dog == Dog: |
|||
if dog == DOG: |
|||
echo "There is only one dog, ", DOG) |
|||
else: |
|||
echo "There are two dogs: ", dog, " and ", DOG |
|||
elif Dog == DOG : |
|||
echo "There are two dogs: ", dog, " and ", DOG |
|||
else: |
|||
echo "There are three dogs: ", dog, ", ", Dog, " and ", DOG</syntaxhighlight> |
|||
block outer: |
|||
while true: |
|||
for n in ran: |
|||
let k = (base - 1) * x + n |
|||
if k < start: |
|||
continue |
|||
if k > ending: |
|||
break outer |
|||
yield k |
|||
inc x |
|||
echo toSeq(castOut(base=16, start=1, ending=255))</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre>There are two dogs: Benjamin and Bernie</pre> |
|||
<pre>@[1, 6, 10, 15, 16, 21, 25, 30, 31, 36, 40, 45, 46, 51, 55, 60, 61, 66, 70, 75, 76, 81, 85, 90, 91, 96, 100, 105, 106, 111, 115, 120, 121, 126, 130, 135, 136, 141, 145, 150, 151, 156, 160, 165, 166, 171, 175, 180, 181, 186, 190, 195, 196, 201, 205, 210, 211, 216, 220, 225, 226, 231, 235, 240, 241, 246, 250, 255]</pre> |
|||
=={{header|Oberon-2}}== |
|||
{{Works with| oo2c Version 2}} |
|||
<syntaxhighlight lang="oberon2"> |
|||
MODULE CaseSensitivity; |
|||
IMPORT |
|||
Out; |
|||
VAR |
|||
dog, Dog, DOG: STRING; |
|||
BEGIN |
|||
dog := "Benjamin"; |
|||
Dog := "Samba"; |
|||
DOG := "Bernie"; |
|||
Out.Object("The three dogs are named " + dog + ", " + Dog + " and " + DOG); |
|||
Out.Ln |
|||
END CaseSensitivity. |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
The three dogs are named Benjamin, Samba and Bernie |
|||
</pre> |
|||
=={{header|Objeck}}== |
|||
Objeck is case sensitive |
|||
<syntaxhighlight lang="objeck">class Program { |
|||
=={{header|Objeck}}== |
|||
<syntaxhighlight lang=objeck>class CastingNines { |
|||
function : Main(args : String[]) ~ Nil { |
function : Main(args : String[]) ~ Nil { |
||
dog := "Benjamin"; |
|||
Dog := "Samba"; |
|||
DOG := "Bernie"; |
|||
"The three dogs are named {$dog}, {$Dog}, and {$DOG}."->PrintLine(); |
|||
c2 := 0; |
|||
for (k:=1; k<base->As(Float)->Power(N->As(Float)); k+=1;){ |
|||
c1+=1; |
|||
if (k%(base-1) = (k*k)%(base-1)){ |
|||
c2+=1; |
|||
IO.Console->Print(k)->Print(" "); |
|||
}; |
|||
}; |
|||
IO.Console->Print("\nTrying ")->Print(c2)->Print(" numbers instead of ") |
|||
->Print(c1)->Print(" numbers saves ")->Print(100 - (c2->As(Float)/c1 |
|||
->As(Float)*100))->PrintLine("%"); |
|||
} |
} |
||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
=={{header|OCaml}}== |
|||
Identifiers in OCaml are lettercase sensitive, but the first letter has to be lowercase. |
|||
{{out}} |
|||
<pre>1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
Trying 22 numbers instead of 99 numbers saves 77.7777778%</pre> |
|||
<syntaxhighlight lang="ocaml">let () = |
|||
=={{header|PARI/GP}}== |
|||
let dog = "Benjamin" in |
|||
{{trans|C++}} |
|||
let dOG = "Samba" in |
|||
<syntaxhighlight lang=parigp>{base=10; |
|||
let dOg = "Bernie" in |
|||
N=2; |
|||
Printf.printf "The three dogs are named %s, %s and %s.\n" dog dOG dOg</syntaxhighlight> |
|||
c1=c2=0; |
|||
=={{header|Oforth}}== |
|||
for(k=1,base^N-1, |
|||
c1++; |
|||
if (k%(base-1) == k^2%(base-1), |
|||
c2++; |
|||
print1(k" ") |
|||
); |
|||
); |
|||
print("\nTrying "c2" numbers instead of "c1" numbers saves " 100.-(c2/c1)*100 "%")} |
|||
</syntaxhighlight> |
|||
{{out|Produces}} |
|||
<pre> |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
Trying 22 numbers instead of 99 numbers saves 77.77777777777777777777777778% |
|||
</pre> |
|||
Changing to: "<code>base = 16;</code>" produces: |
|||
<pre> |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 |
|||
105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 |
|||
180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 |
|||
255 |
|||
Trying 68 numbers instead of 255 numbers saves 73.33333333333333333333333333%</pre> |
|||
Oforth is case-sensitive. |
|||
=={{header|Perl}}== |
|||
<syntaxhighlight lang=perl>sub co9 { # Follows the simple procedure asked for in Part 1 |
|||
my $n = shift; |
|||
return $n if $n < 10; |
|||
my $sum = 0; $sum += $_ for split(//,$n); |
|||
co9($sum); |
|||
} |
|||
<syntaxhighlight lang="oforth">: threeDogs |
|||
sub showadd { |
|||
| dog Dog DOG | |
|||
my($n,$m) = @_; |
|||
print "( $n [",co9($n),"] + $m [",co9($m),"] ) [",co9(co9($n)+co9($m)),"]", |
|||
" = ", $n+$m," [",co9($n+$m),"]\n"; |
|||
} |
|||
"Benjamin" ->dog |
|||
sub co9filter { |
|||
"Samba" ->Dog |
|||
"Bernie" ->DOG |
|||
die unless $base >= 2; |
|||
my($beg, $end, $basem1) = (1, $base*$base-1, $base-1); |
|||
my @list = grep { $_ % $basem1 == $_*$_ % $basem1 } $beg .. $end; |
|||
($end, scalar(@list), @list); |
|||
} |
|||
System.Out "The three dogs are named " << dog << ", " << Dog << " and " << DOG << "." << cr ;</syntaxhighlight> |
|||
print "Part 1: Create a simple filter and demonstrate using simple example.\n"; |
|||
=={{header|Ol}}== |
|||
showadd(6395, 1259); |
|||
<syntaxhighlight lang="scheme"> |
|||
(define dog "Benjamin") |
|||
print "\nPart 2: Use this to filter a range with co9(k) == co9(k^2).\n"; |
|||
(define Dog "Samba") |
|||
print join(" ", grep { co9($_) == co9($_*$_) } 1..99), "\n"; |
|||
(define DOG "Bernie") |
|||
print "\nPart 3: Use efficient method on range.\n"; |
|||
(print "The three dogs are named " dog ", " Dog " and " DOG ".\n") |
|||
for my $base (10, 17) { |
|||
</syntaxhighlight> |
|||
my($N, $n, @l) = co9filter($base); |
|||
{{Out}} |
|||
printf "[@l]\nIn base %d, trying %d numbers instead of %d saves %.4f%%\n\n", |
|||
$base, $n, $N, 100-($n/$N)*100; |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
<pre> |
||
The three dogs are named Benjamin, Samba and Bernie. |
|||
Part 1: Create a simple filter and demonstrate using simple example. |
|||
( 6395 [5] + 1259 [8] ) [4] = 7654 [4] |
|||
Part 2: Use this to filter a range with co9(k) == co9(k^2). |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
Part 3: Use efficient method on range. |
|||
[1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99] |
|||
In base 10, trying 22 numbers instead of 99 saves 77.7778% |
|||
[1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 192 193 208 209 224 225 240 241 256 257 272 273 288] |
|||
In base 17, trying 36 numbers instead of 288 saves 87.5000% |
|||
</pre> |
</pre> |
||
=={{header|PARI/GP}}== |
|||
<syntaxhighlight lang="parigp">dog="Benjamin"; |
|||
Dog="Samba"; |
|||
DOG="Bernie"; |
|||
printf("The three dogs are named %s, %s, and %s.", dog, Dog, DOG)</syntaxhighlight> |
|||
=={{header|Pascal}}== |
|||
See [[#Delphi|Delphi]] |
|||
=={{header|Perl}}== |
|||
<syntaxhighlight lang="perl"># These variables are all different |
|||
$dog='Benjamin'; |
|||
$Dog='Samba'; |
|||
$DOG='Bernie'; |
|||
print "The three dogs are named $dog, $Dog, and $DOG \n"</syntaxhighlight> |
|||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
{{libheader|Phix/basics}} |
|||
<!--<syntaxhighlight lang=Phix>(phixonline)--> |
|||
Phix is case sensitive |
|||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
|||
<span style="color: #008080;">procedure</span> <span style="color: #000000;">co9</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">start</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">lim</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">kaprekars</span><span style="color: #0000FF;">)</span> |
|||
<!--<syntaxhighlight lang="phix">--> |
|||
<span style="color: #004080;">integer</span> <span style="color: #000000;">c1</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">dog</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Benjamin"<span style="color: #0000FF;">,</span> |
|||
<span style="color: # |
<span style="color: #000000;">Dog</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Samba"<span style="color: #0000FF;">,</span> |
||
<span style="color: #000000;">DOG</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Bernie"</span> |
|||
<span style="color: # |
<span style="color: #7060A8;">printf<span style="color: #0000FF;">(</span> <span style="color: #000000;">1<span style="color: #0000FF;">,</span> <span style="color: #008000;">"The three dogs are named %s, %s and %s\n"<span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{<span style="color: #000000;">dog<span style="color: #0000FF;">,</span> <span style="color: #000000;">Dog<span style="color: #0000FF;">,</span> <span style="color: #000000;">DOG<span style="color: #0000FF;">}</span> <span style="color: #0000FF;">) |
||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">,</span><span style="color: #000000;">base</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)=</span><span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">*</span><span style="color: #000000;">k</span><span style="color: #0000FF;">,</span><span style="color: #000000;">base</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #000000;">c2</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span> |
|||
<span style="color: #000000;">s</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">k</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #004080;">string</span> <span style="color: #000000;">msg</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"valid subset"</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">kaprekars</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">kaprekars</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #000000;">msg</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"***INVALID***"</span> |
|||
<span style="color: #008080;">exit</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)></span><span style="color: #000000;">25</span> <span style="color: #008080;">then</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">10</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">10</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"..."</span><span style="color: #0000FF;">}</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</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;">"%V\nKaprekar numbers: %V - %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">kaprekars</span><span style="color: #0000FF;">,</span><span style="color: #000000;">msg</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;">"Trying %d numbers instead of %d saves %3.2f%%\n\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">c2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">c1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">100</span><span style="color: #0000FF;">-(</span><span style="color: #000000;">c2</span><span style="color: #0000FF;">/</span><span style="color: #000000;">c1</span><span style="color: #0000FF;">)*</span><span style="color: #000000;">100</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span> |
|||
<span style="color: #000000;">co9</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">99</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">45</span><span style="color: #0000FF;">,</span><span style="color: #000000;">55</span><span style="color: #0000FF;">,</span><span style="color: #000000;">99</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #000000;">co9</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0(17)10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">17</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">17</span><span style="color: #0000FF;">*</span><span style="color: #000000;">17</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">0(17)3d</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(17)d4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0(17)gg</span><span style="color: #0000FF;">})</span> |
|||
<span style="color: #000000;">co9</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1000</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">45</span><span style="color: #0000FF;">,</span><span style="color: #000000;">55</span><span style="color: #0000FF;">,</span><span style="color: #000000;">99</span><span style="color: #0000FF;">,</span><span style="color: #000000;">297</span><span style="color: #0000FF;">,</span><span style="color: #000000;">703</span><span style="color: #0000FF;">,</span><span style="color: #000000;">999</span><span style="color: #0000FF;">})</span> |
|||
<!--</syntaxhighlight>--> |
<!--</syntaxhighlight>--> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
The three dogs are named Benjamin, Samba and Bernie |
|||
{1,9,10,18,19,27,28,36,37,45,46,54,55,63,64,72,73,81,82,90,91,99} |
|||
Kaprekar numbers: {1,9,45,55,99} - valid subset |
|||
Trying 22 numbers instead of 99 saves 77.78% |
|||
{17,32,33,48,49,64,65,80,81,"...",225,240,241,256,257,272,273,288,289} |
|||
Kaprekar numbers: {64,225,288} - valid subset |
|||
Trying 35 numbers instead of 273 saves 87.18% |
|||
{1,9,10,18,19,27,28,36,37,"...",964,972,973,981,982,990,991,999,1000} |
|||
Kaprekar numbers: {1,9,45,55,99,297,703,999} - valid subset |
|||
Trying 223 numbers instead of 1000 saves 77.70% |
|||
</pre> |
</pre> |
||
=={{header|Picat}}== |
|||
<syntaxhighlight lang=Picat>go => |
|||
Base10 = 10, |
|||
foreach(N in [2,6]) |
|||
casting_out_nines(Base10,N) |
|||
end, |
|||
nl, |
|||
Base16 = 16, |
|||
foreach(N in [2,6]) |
|||
casting_out_nines(Base16,N) |
|||
end, |
|||
nl. |
|||
casting_out_nines(Base,N) => |
|||
println([base=Base,n=N]), |
|||
C1 = 0, |
|||
C2 = 0, |
|||
Ks = [], |
|||
LimitN = 3, |
|||
foreach(K in 1..Base**N-1) |
|||
C1 := C1 + 1, |
|||
if K mod (Base-1) == (K*K) mod (Base-1) then |
|||
C2 := C2+1, |
|||
if N <= LimitN then |
|||
Ks := Ks ++ [K] |
|||
end |
|||
end |
|||
end, |
|||
if C2 <= 100 then |
|||
println(ks=Ks) |
|||
end, |
|||
printf("Trying %d numbers instead of %d numbers saves %2.3f%%\n", C2, C1, 100 - ((C2/C1)*100)), |
|||
nl.</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[base = 10,n = 2] |
|||
ks = [1,9,10,18,19,27,28,36,37,45,46,54,55,63,64,72,73,81,82,90,91,99] |
|||
Trying 22 numbers instead of 99 numbers saves 77.778% |
|||
[base = 10,n = 6] |
|||
Trying 222222 numbers instead of 999999 numbers saves 77.778% |
|||
[base = 16,n = 2] |
|||
ks = [1,6,10,15,16,21,25,30,31,36,40,45,46,51,55,60,61,66,70,75,76,81,85,90,91,96,100,105,106,111,115,120,121,126,130,135,136,141,145,150,151,156,160,165,166,171,175,180,181,186,190,195,196,201,205,210,211,216,220,225,226,231,235,240,241,246,250,255] |
|||
Trying 68 numbers instead of 255 numbers saves 73.333% |
|||
[base = 16,n = 6] |
|||
Trying 4473924 numbers instead of 16777215 numbers saves 73.333%</pre> |
|||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="picolisp">(let (dog "Benjamin" Dog "Samba" DOG "Bernie") |
||
(prinl "The three dogs are named " dog ", " Dog " and " DOG) )</syntaxhighlight> |
|||
(let L (cons 0 (chop (* N N))) |
|||
Output: |
|||
(for ((I . R) (cdr L) R (cdr R)) |
|||
<pre>The three dogs are named Benjamin, Samba and Bernie</pre> |
|||
(NIL (gt0 (format R))) |
|||
=={{header|PL/I}}== |
|||
(T (= N (+ @ (format (head I L)))) N) ) ) ) |
|||
<syntaxhighlight lang="pli">*process or(!) source xref attributes macro options; |
|||
/********************************************************************* |
|||
(de co9 (N) |
|||
* Program to show that PL/I is case-insensitive |
|||
(until |
|||
* 28.05.2013 Walter Pachl |
|||
(> 9 |
|||
*********************************************************************/ |
|||
(setq N |
|||
case: proc options(main); |
|||
(sum |
|||
Dcl dog Char(20) Var; |
|||
'((N) (unless (= "9" N) (format N))) |
|||
dog = "Benjamin"; |
|||
(chop N) ) ) ) ) |
|||
Dog = "Samba"; |
|||
N ) |
|||
DOG = "Bernie"; |
|||
Put Edit(dog,Dog,DOG)(Skip,3(a,x(1))); |
|||
(println 'Part1:) |
|||
End;</syntaxhighlight> |
|||
(println |
|||
'''Output''' |
|||
(= |
|||
<pre>Bernie Bernie Berni</pre> |
|||
(co9 (+ 6395 1259)) |
|||
=={{header|Plain English}}== |
|||
(co9 (+ (co9 6395) (co9 1259))) ) ) |
|||
Plain English is NOT case sensitive. |
|||
<syntaxhighlight lang="plainenglish">To run: |
|||
(println 'Part2:) |
|||
Start up. |
|||
(println |
|||
Put "Benjamin" into a DOG string. |
|||
(filter |
|||
Put "Samba" into the Dog string. |
|||
'((N) (= (co9 N) (co9 (* N N)))) |
|||
Put "Bernie" into the dog string. |
|||
(range 1 100) ) ) |
|||
Write "There is just one dog named " then the DOG on the console. |
|||
(println |
|||
Wait for the escape key. |
|||
(filter kaprekar (range 1 100)) ) |
|||
Shut down.</syntaxhighlight> |
|||
(println 'Part3 '- 'base17:) |
|||
(println |
|||
(filter |
|||
'((N) (= (% N 16) (% (* N N) 16))) |
|||
(range 1 100) ) ) |
|||
(bye)</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
There is just one dog named Bernie |
|||
Part1: |
|||
T |
|||
Part2: |
|||
(1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100) |
|||
(1 9 45 55 99) |
|||
Part3 - base17: |
|||
(1 16 17 32 33 48 49 64 65 80 81 96 97) |
|||
</pre> |
</pre> |
||
=={{header|PowerShell}}== |
|||
PowerShell is not case sensitive. |
|||
<syntaxhighlight lang="powershell"> |
|||
$dog = "Benjamin" |
|||
$Dog = "Samba" |
|||
$DOG = "Bernie" |
|||
"There is just one dog named {0}." -f $dOg |
|||
=={{header|Python}}== |
|||
</syntaxhighlight> |
|||
This works slightly differently, generating the "wierd" (as defined by Counting Out Nines) numbers which may be Kaprekar, rather than filtering all numbers in a range. |
|||
{{Out}} |
|||
<syntaxhighlight lang=Python># Casting out Nines |
|||
# |
|||
# Nigel Galloway: June 27th., 2012, |
|||
# |
|||
def CastOut(Base=10, Start=1, End=999999): |
|||
ran = [y for y in range(Base-1) if y%(Base-1) == (y*y)%(Base-1)] |
|||
x,y = divmod(Start, Base-1) |
|||
while True: |
|||
for n in ran: |
|||
k = (Base-1)*x + n |
|||
if k < Start: |
|||
continue |
|||
if k > End: |
|||
return |
|||
yield k |
|||
x += 1 |
|||
for V in CastOut(Base=16,Start=1,End=255): |
|||
print(V, end=' ')</syntaxhighlight> |
|||
Produces: |
|||
<pre> |
<pre> |
||
There is just one dog named Bernie. |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255 |
|||
</pre> |
</pre> |
||
=={{header|Prolog}}== |
|||
<code>CastOut(Base=10,Start=1,End=99)</code> produces: |
|||
In Prolog, the initial of a variable must be a uppercase letter. So the task can't be completed but we can write this code : |
|||
<pre> |
|||
<syntaxhighlight lang="prolog">three_dogs :- |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
DoG = 'Benjamin', |
|||
Dog = 'Samba', |
|||
DOG = 'Bernie', |
|||
format('The three dogs are named ~w, ~w and ~w.~n', [DoG, Dog, DOG]). |
|||
</syntaxhighlight> |
|||
The output is : |
|||
<pre>?- three_dogs. |
|||
The three dogs are named Benjamin, Samba and Bernie. |
|||
true. |
|||
</pre> |
</pre> |
||
=={{header|PureBasic}}== |
|||
<code>CastOut(Base=17,Start=1,End=288)</code> produces: |
|||
<syntaxhighlight lang="purebasic">dog$="Benjamin" |
|||
<pre> |
|||
Dog$="Samba" |
|||
1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 192 193 208 209 224 225 240 241 256 257 272 273 288 |
|||
DOG$="Bernie" |
|||
</pre> |
|||
Debug "There is just one dog named "+dog$</syntaxhighlight> |
|||
=={{header|Python}}== |
|||
Python names are case sensitive: |
|||
<syntaxhighlight lang="python">>>> dog = 'Benjamin'; Dog = 'Samba'; DOG = 'Bernie' |
|||
>>> print ('The three dogs are named ',dog,', ',Dog,', and ',DOG) |
|||
The three dogs are named Benjamin , Samba , and Bernie |
|||
>>> </syntaxhighlight> |
|||
=={{header|Quackery}}== |
=={{header|Quackery}}== |
||
<syntaxhighlight lang="quackery">[ $ 'Benjamin' ] is dog ( --> $ ) |
|||
[ $ 'Samba' ] is Dog ( --> $ ) |
|||
<code>kaprekar</code> is defined at [[Kaprekar numbers#Quackery]]. |
|||
[ $ 'Bernie' ] is DOG ( --> $ ) |
|||
<syntaxhighlight lang=Quackery> [ true unrot swap |
|||
witheach |
|||
[ over find |
|||
over found not if |
|||
[ dip not |
|||
conclude ] ] |
|||
drop ] is subset ( [ [ --> [ ) |
|||
[ abs 0 swap |
|||
[ 10 /mod rot + |
|||
dup 8 > if [ 9 - ] |
|||
swap dup 0 = until ] |
|||
drop ] is co9 ( n --> n ) |
|||
say "Part 1: Examples from Dr Math page." cr cr |
|||
say "6395 1259 + = " 6395 1259 + echo cr |
|||
say "6395 co9 = " 6395 co9 echo cr |
|||
say "1259 co9 = " 1259 co9 echo cr |
|||
say "5 8 + co9 = " 5 8 + co9 echo cr |
|||
say "7654 co9 = " 7654 co9 echo cr cr |
|||
say "6395 1259 * = " 6395 1259 * echo cr |
|||
say "6395 co9 = " 6395 co9 echo cr |
|||
say "1259 co9 = " 1259 co9 echo cr |
|||
say "5 8 * co9 = " 5 8 * co9 echo cr |
|||
say "8051305 co9 = " 7654 co9 echo cr cr |
|||
say "Part 2: Kaprekar numbers." cr cr |
|||
say "Kaprekar numbers less than one hundred: " |
|||
[] |
|||
100 times |
|||
[ i^ kaprekar if |
|||
[ i^ join ] ] |
|||
dup echo cr |
|||
say '0...99 with property "n co9 n 2 ** co9 =": ' |
|||
[] |
|||
100 times |
|||
[ i^ co9 |
|||
i^ 2 ** co9 = if |
|||
[ i^ join ] ] |
|||
dup echo cr |
|||
say "Is the former a subset of the latter? " |
|||
subset iff [ say "Yes." ] else [ say "No." ] cr cr |
|||
say "Part 3: Same as Part 2, but base 17." cr cr |
|||
say "Kaprekar (base 17) numbers less than one hundred: " |
|||
17 base put |
|||
[] |
|||
100 times |
|||
[ i^ kaprekar if |
|||
[ i^ join ] ] |
|||
base release |
|||
dup echo cr |
|||
say '0...99 with property "n 16 mod n 2 ** 16 mod =": ' |
|||
[] |
|||
100 times |
|||
[ i^ 16 mod |
|||
i^ 2 ** 16 mod = if |
|||
[ i^ join ] ] |
|||
dup echo cr |
|||
say "Is the former a subset of the latter? " |
|||
subset iff [ say "Yes." ] else [ say "No." ]</syntaxhighlight> |
|||
say 'There are three dogs named ' |
|||
dog echo$ say ', ' |
|||
Dog echo$ say ', and ' |
|||
DOG echo$ say '.' cr</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre> |
|||
There are three dogs named Benjamin, Samba, and Bernie. |
|||
</pre> |
|||
=={{header|R}}== |
|||
<syntaxhighlight lang="r">dog <- 'Benjamin' |
|||
Dog <- 'Samba' |
|||
DOG <- 'Bernie' |
|||
# Having fun with cats and dogs |
|||
<pre>Part 1: Examples from Dr Math page. |
|||
cat('The three dogs are named ') |
|||
cat(dog) |
|||
cat(', ') |
|||
cat(Dog) |
|||
cat(' and ') |
|||
cat(DOG) |
|||
cat('.\n') |
|||
# In one line it would be: |
|||
# cat('The three dogs are named ', dog, ', ', Dog, ' and ', DOG, '.\n', sep = '')</syntaxhighlight> |
|||
Output: |
|||
6395 1259 + = 7654 |
|||
<pre> |
|||
6395 co9 = 5 |
|||
The three dogs are named Benjamin, Samba and Bernie. |
|||
1259 co9 = 8 |
|||
5 8 + co9 = 4 |
|||
7654 co9 = 4 |
|||
6395 1259 * = 8051305 |
|||
6395 co9 = 5 |
|||
1259 co9 = 8 |
|||
5 8 * co9 = 4 |
|||
8051305 co9 = 4 |
|||
Part 2: Kaprekar numbers. |
|||
Kaprekar numbers less than one hundred: [ 1 9 45 55 99 ] |
|||
0...99 with property "n co9 n 2 ** co9 =": [ 0 1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 ] |
|||
Is the former a subset of the latter? Yes. |
|||
Part 3: Same as Part 2, but base 17. |
|||
Kaprekar (base 17) numbers less than one hundred: [ 1 16 64 ] |
|||
0...99 with property "n 16 mod n 2 ** 16 mod =": [ 0 1 16 17 32 33 48 49 64 65 80 81 96 97 ] |
|||
Is the former a subset of the latter? Yes. |
|||
</pre> |
</pre> |
||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
The default setting for the Racket reader is to be case sensitive: |
|||
<syntaxhighlight lang=racket>#lang racket |
|||
<syntaxhighlight lang="racket"> |
|||
(require math) |
|||
#lang racket |
|||
(define |
(define dog "Benjamin") |
||
(define Dog "Samba") |
|||
(map (compose1 string->number string) |
|||
(define DOG "Bernie") |
|||
(string->list (number->string n)))) |
|||
(if (equal? dog DOG) |
|||
(define (cast-out-nines n) |
|||
(displayln (~a "There is one dog named " DOG ".")) |
|||
(with-modulus 9 |
|||
(displayln (~a "The three dogs are named " dog ", " Dog ", and, " DOG "."))) |
|||
(for/fold ([sum 0]) ([d (digits n)]) |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
The three dogs are named Benjamin, Samba, and, Bernie. |
|||
</pre> |
|||
If you need case insensitive identifiers, then use #ci to turn on case insensitivity: |
|||
<syntaxhighlight lang="racket"> |
|||
#lang racket |
|||
#ci(module dogs racket |
|||
(define dog "Benjamin") |
|||
(set! Dog "Samba") |
|||
(set! DOG "Bernie") |
|||
(if (equal? dog DOG) |
|||
(displayln (~a "There is one dog named " DOG ".")) |
|||
(displayln (~a "The three dogs are named " dog ", " Dog ", and, " DOG ".")))) |
|||
(require 'dogs) |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
There is one dog named Bernie. |
|||
</pre> |
|||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
(formerly Perl 6) |
(formerly Perl 6) |
||
<syntaxhighlight lang="raku" line>my $dog = 'Benjamin'; |
|||
{{trans|Python}} |
|||
my $Dog = 'Samba'; |
|||
{{works with|Rakudo|2015.12}} |
|||
my $DOG = 'Bernie'; |
|||
<syntaxhighlight lang=raku line>sub cast-out(\BASE = 10, \MIN = 1, \MAX = BASE**2 - 1) { |
|||
say "The three dogs are named $dog, $Dog, and $DOG."</syntaxhighlight> |
|||
my \B9 = BASE - 1; |
|||
The only place that Raku pays any attention to the case of identifiers is that, for certain error messages, it will guess that an identifier starting lowercase is probably a function name, while one starting uppercase is probably a type or constant name. But this case distinction is merely a convention in Raku, not mandatory: |
|||
my @ran = ($_ if $_ % B9 == $_**2 % B9 for ^B9); |
|||
<syntaxhighlight lang="raku" line>constant dog = 'Benjamin'; |
|||
my $x = MIN div B9; |
|||
sub Dog() { 'Samba' } |
|||
gather loop { |
|||
my &DOG = { 'Bernie' } |
|||
for @ran -> \n { |
|||
say "The three dogs are named {dog}, {Dog}, and {DOG}."</syntaxhighlight> |
|||
my \k = B9 * $x + n; |
|||
=={{header|Retro}}== |
|||
take k if k >= MIN; |
|||
Retro is case sensitive. |
|||
} |
|||
$x++; |
|||
} ...^ * > MAX; |
|||
} |
|||
<syntaxhighlight lang="retro">: dog ( -$ ) "Benjamin" ; |
|||
say cast-out; |
|||
: Dog ( -$ ) "Samba" ; |
|||
say cast-out 16; |
|||
: DOG ( -$ ) "Bernie" ; |
|||
say cast-out 17;</syntaxhighlight> |
|||
{{out}} |
|||
<pre>(1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99) |
|||
(1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255) |
|||
(1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 192 193 208 209 224 225 240 241 256 257 272 273 288)</pre> |
|||
DOG Dog dog "The three dogs are named %s, %s, and %s.\n" puts</syntaxhighlight> |
|||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
===simple variables=== |
|||
<syntaxhighlight lang=rexx>/*REXX program demonstrates the casting─out─nines algorithm (with Kaprekar numbers). */ |
|||
The REXX language is case insensitive (with respect to simple variables). |
|||
parse arg LO HI base . /*obtain optional arguments from the CL*/ |
|||
<syntaxhighlight lang="rexx">/*REXX program demonstrate case insensitivity for simple REXX variable names. */ |
|||
if LO=='' | LO=="," then do; LO=1; HI=1000; end /*Not specified? Then use the default*/ |
|||
if HI=='' | HI=="," then HI= LO /* " " " " " " */ |
|||
if base=='' | base=="," then base= 10 /* " " " " " " */ |
|||
numeric digits max(9, 2*length(HI**2) ) /*insure enough decimal digits for HI².*/ |
|||
numbers= castOut(LO, HI, base) /*generate a list of (cast out) numbers*/ |
|||
@cast_out= 'cast-out-' || (base-1) "test" /*construct a shortcut text for output.*/ |
|||
say 'For' LO "through" HI', the following passed the' @cast_out":" |
|||
say numbers; say /*display the list of cast out numbers.*/ |
|||
q= HI - LO + 1 /*Q: is the range of numbers in list.*/ |
|||
p= words(numbers) /*P" " " number " " " " */ |
|||
pc= format(p/q * 100, , 2) / 1 || '%' /*calculate the percentage (%) cast out*/ |
|||
say 'For' q "numbers," p 'passed the' @cast_out "("pc') for base' base"." |
|||
if base\==10 then exit /*if radix isn't ten, then exit program*/ |
|||
Kaps= Kaprekar(LO, HI) /*generate a list of Kaprekar numbers. */ |
|||
say; say 'The Kaprekar numbers in the same range are:' Kaps |
|||
say |
|||
do i=1 for words(Kaps); x= word(Kaps, i) /*verify 'em in list.*/ |
|||
if wordpos(x, numbers)\==0 then iterate /*it's OK so far ··· */ |
|||
say 'Kaprekar number' x "isn't in the numbers list." /*oops─ay! */ |
|||
exit 13 /*go spank the coder.*/ |
|||
end /*i*/ |
|||
/* ┌──◄── all 3 left─hand side REXX variables are identical (as far as assignments). */ |
|||
say 'All Kaprekar numbers are in the' @cast_out "numbers list." /*OK*/ |
|||
/* │ */ |
|||
/* ↓ */ |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
dog= 'Benjamin' /*assign a lowercase variable (dog)*/ |
|||
castOut: procedure; parse arg low,high,radix; rm= word(radix 10, 1) - 1; $= |
|||
Dog= 'Samba' /* " " capitalized " Dog */ |
|||
DOG= 'Bernie' /* " an uppercase " DOG */ |
|||
end /*j*/ /* [↑] Then add # to list.*/ |
|||
return strip($) /*strip and leading blanks from result.*/ |
|||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
|||
Kaprekar: procedure; parse arg L,H; $=; if L<=1 then $= 1 /*add unity if in range*/ |
|||
do j=max(2, L) to H; s= j*j /*a slow way to find Kaprekar numbers. */ |
|||
do m=1 for length(s)%2 |
|||
if j==left(s, m) + substr(s, m+1) then do; $= $ j; leave; end |
|||
end /*m*/ /* [↑] found a Kaprekar number. */ |
|||
end /*j*/ |
|||
return strip($) /*return Kaprekar numbers to invoker. */</syntaxhighlight> |
|||
{{out|output|text= when using the default inputs:}} |
|||
<pre> |
|||
For 1 through 1000, the following passed the cast-out-9 test: |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 100 108 109 117 118 126 127 135 136 144 145 153 154 162 163 171 172 180 181 189 190 198 199 207 208 216 217 225 226 234 235 243 244 252 |
|||
253 261 262 270 271 279 280 288 289 297 298 306 307 315 316 324 325 333 334 342 343 351 352 360 361 369 370 378 379 387 388 396 397 405 406 414 415 423 424 432 433 441 442 450 451 459 460 468 469 477 |
|||
478 486 487 495 496 504 505 513 514 522 523 531 532 540 541 549 550 558 559 567 568 576 577 585 586 594 595 603 604 612 613 621 622 630 631 639 640 648 649 657 658 666 667 675 676 684 685 693 694 702 |
|||
703 711 712 720 721 729 730 738 739 747 748 756 757 765 766 774 775 783 784 792 793 801 802 810 811 819 820 828 829 837 838 846 847 855 856 864 865 873 874 882 883 891 892 900 901 909 910 918 919 927 |
|||
928 936 937 945 946 954 955 963 964 972 973 981 982 990 991 999 1000 |
|||
say center('using simple variables', 35, "─") /*title.*/ |
|||
For 1000 numbers, 223 passed the cast-out-9 test (22.3%) for base 10. |
|||
say |
|||
if dog\==Dog | DOG\==dog then say 'The three dogs are named:' dog"," Dog 'and' DOG"." |
|||
The Kaprekar numbers in the same range are: 1 9 45 55 99 297 703 999 |
|||
else say 'There is just one dog named:' dog"." |
|||
/*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
All Kaprekar numbers are in the cast-out-9 test numbers list. |
|||
'''output''' |
|||
</pre> |
|||
{{out|output|text= when using the input of: <tt> 1 256 16 </tt>}} |
|||
<pre> |
<pre> |
||
──────using simple variables─────── |
|||
For 1 through 256, the following passed the cast-out-15 test: |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 |
|||
216 220 225 226 231 235 240 241 246 250 255 256 |
|||
There is just one dog named: Bernie. |
|||
For 256 numbers, 69 passed the cast-out-15 test (26.95%) for base 16. |
|||
</pre> |
</pre> |
||
===compound variables=== |
|||
=={{header|Ring}}== |
|||
However, the REXX language is case sensitive (with respect to compound variables, or indices). |
|||
<syntaxhighlight lang=ring> |
|||
<syntaxhighlight lang="rexx">/*REXX program demonstrate case sensitive REXX index names (for compound variables). */ |
|||
# Project : Casting out nines |
|||
/* ┌──◄── all 3 indices (for an array variable) are unique (as far as array index). */ |
|||
/* │ */ |
|||
/* ↓ */ |
|||
x= 'dog'; dogname.x= "Gunner" /*assign an array index, lowercase dog*/ |
|||
x= 'Dog'; dogname.x= "Thor" /* " " " " capitalized Dog*/ |
|||
x= 'DOG'; dogname.x= "Jax" /* " " " " uppercase DOG*/ |
|||
x= 'doG'; dogname.x= "Rex" /* " " " " mixed doG*/ |
|||
say center('using compound variables', 35, "═") /*title.*/ |
|||
co9(1, 10, 99, [1,9,45,55,99]) |
|||
say |
|||
co9(1, 10, 1000, [1,9,45,55,99,297,703,999]) |
|||
_= 'dog'; say "dogname.dog=" dogname._ /*display an array index, lowercase dog*/ |
|||
func co9(start,base,lim,kaprekars) |
|||
_= 'Dog'; say "dogname.Dog=" dogname._ /* " " " " capitalized Dog*/ |
|||
c1=0 |
|||
_= 'DOG'; say "dogname.DOG=" dogname._ /* " " " " uppercase DOG*/ |
|||
c2=0 |
|||
_= 'doG'; say "dogname.doG=" dogname._ /* " " " " mixed doG*/ |
|||
s = [] |
|||
for k = start to lim |
|||
c1 = c1 + 1 |
|||
if k % (base-1) = (k*k) % (base-1) |
|||
c2 = c2 + 1 |
|||
add(s,k) |
|||
ok |
|||
next |
|||
msg = "Valid subset" + nl |
|||
for i = 1 to len(kaprekars) |
|||
if not find(s,kaprekars[i]) |
|||
msg = "***Invalid***" + nl |
|||
exit |
|||
ok |
|||
next |
|||
showarray(s) |
|||
see "Kaprekar numbers:" + nl |
|||
showarray(kaprekars) |
|||
see msg |
|||
see "Trying " + c2 + " numbers instead of " + c1 + " saves " + (100-(c2/c1)*100) + "%" + nl + nl |
|||
/*stick a fork in it, we're all done. */</syntaxhighlight> |
|||
func showarray(vect) |
|||
'''output''' |
|||
see "{" |
|||
svect = "" |
|||
for n = 1 to len(vect) |
|||
svect = svect + vect[n] + ", " |
|||
next |
|||
svect = left(svect, len(svect) - 2) |
|||
see svect + "}" + nl |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
<pre> |
||
═════using compound variables══════ |
|||
{1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, 81, 82, 90, 91, 99} |
|||
Kaprekar numbers: |
|||
{1, 9, 45, 55, 99} |
|||
Valid subset |
|||
Trying 22 numbers instead of 99 saves 77.78% |
|||
dogname.dog= Gunner |
|||
{1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, 81, 82, 90, 91, 99, 100, 108, 109, 117, 118, 126, 127, 135, 136, 144, 145, 153, 154, 162, 163, 171, 172, 180, 181, 189, 190, 198, 199, 207, 208, 216, 217, 225, 226, 234, 235, 243, 244, 252, 253, 261, 262, 270, 271, 279, 280, 288, 289, 297, 298, 306, 307, 315, 316, 324, 325, 333, 334, 342, 343, 351, 352, 360, 361, 369, 370, 378, 379, 387, 388, 396, 397, 405, 406, 414, 415, 423, 424, 432, 433, 441, 442, 450, 451, 459, 460, 468, 469, 477, 478, 486, 487, 495, 496, 504, 505, 513, 514, 522, 523, 531, 532, 540, 541, 549, 550, 558, 559, 567, 568, 576, 577, 585, 586, 594, 595, 603, 604, 612, 613, 621, 622, 630, 631, 639, 640, 648, 649, 657, 658, 666, 667, 675, 676, 684, 685, 693, 694, 702, 703, 711, 712, 720, 721, 729, 730, 738, 739, 747, 748, 756, 757, 765, 766, 774, 775, 783, 784, 792, 793, 801, 802, 810, 811, 819, 820, 828, 829, 837, 838, 846, 847, 855, 856, 864, 865, 873, 874, 882, 883, 891, 892, 900, 901, 909, 910, 918, 919, 927, 928, 936, 937, 945, 946, 954, 955, 963, 964, 972, 973, 981, 982, 990, 991, 999, 1000} |
|||
dogname.Dog= Thor |
|||
Kaprekar numbers: |
|||
dogname.DOG= Jax |
|||
{1, 9, 45, 55, 99, 297, 703, 999} |
|||
dogname.doG= Rex |
|||
Valid subset |
|||
Trying 223 numbers instead of 1000 saves 77.70% |
|||
</pre> |
</pre> |
||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
dog = "Benjamin" |
|||
doG = "Smokey" |
|||
Dog = "Samba" |
|||
DOG = "Bernie" |
|||
see "The 4 dogs are : " + dog + ", " + doG + ", " + Dog + " and " + DOG + "." |
|||
</syntaxhighlight> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
Ruby gives a special meaning to the first letter of a name. A lowercase letter starts a local variable. An uppercase letter starts a constant. So <tt>dog</tt> is a local variable, but <tt>Dog</tt> and <tt>DOG</tt> are constants. To adapt this task to Ruby, I added <tt>dOg</tt> and <tt>doG</tt> so that I have more than one local variable. |
|||
{{trans|C}} |
|||
<syntaxhighlight lang=ruby>N = 2 |
|||
base = 10 |
|||
c1 = 0 |
|||
c2 = 0 |
|||
<syntaxhighlight lang="ruby">module FiveDogs |
|||
for k in 1 .. (base ** N) - 1 |
|||
dog = "Benjamin" |
|||
dOg = "Dogley" |
|||
if k % (base - 1) == (k * k) % (base - 1) then |
|||
doG = "Fido" |
|||
Dog = "Samba" # this constant is FiveDogs::Dog |
|||
DOG = "Bernie" # this constant is FiveDogs::DOG |
|||
end |
|||
end |
|||
names = [dog, dOg, doG, Dog, DOG] |
|||
puts |
|||
names.uniq! |
|||
print "Trying %d numbers instead of %d numbers saves %f%%" % [c2, c1, 100.0 - 100.0 * c2 / c1]</syntaxhighlight> |
|||
puts "There are %d dogs named %s." % [names.length, names.join(", ")] |
|||
{{out}} |
|||
puts |
|||
<pre>1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
puts "The local variables are %s." % local_variables.join(", ") |
|||
Trying 22 numbers instead of 99 numbers saves 77.777778%</pre> |
|||
puts "The constants are %s." % constants.join(", ") |
|||
end</syntaxhighlight> |
|||
Output: <pre>There are 5 dogs named Benjamin, Dogley, Fido, Samba, Bernie. |
|||
The local variables are dog, dOg, doG, names. |
|||
The constants are Dog, DOG.</pre> |
|||
=={{header|Run BASIC}}== |
|||
<syntaxhighlight lang="runbasic"> |
|||
dog$ = "Benjamin" |
|||
doG$ = "Smokey" |
|||
Dog$ = "Samba" |
|||
DOG$ = "Bernie" |
|||
print "The 4 dogs are "; dog$; ", "; doG$; ", "; Dog$; " and "; DOG$; "." |
|||
</syntaxhighlight> |
|||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
Rust style dictates that identifiers should be written in snake case, e.g. <tt>big_dog</tt>, <tt>small_dog</tt>; whereas types (structs and enums) should be written in camel case, e.g. <tt>BigDog</tt>, <tt>SmallDog</tt>. Failing to comply with this standard does not cause a compiler error, but it will trigger a compiler warning, and the culture is very strongly towards compliance with this standard. |
|||
<syntaxhighlight lang=Rust>fn compare_co9_efficiency(base: u64, upto: u64) { |
|||
let naive_candidates: Vec<u64> = (1u64..upto).collect(); |
|||
let co9_candidates: Vec<u64> = naive_candidates.iter().cloned() |
|||
.filter(|&x| x % (base - 1) == (x * x) % (base - 1)) |
|||
.collect(); |
|||
for candidate in &co9_candidates { |
|||
print!("{} ", candidate); |
|||
} |
|||
println!(); |
|||
println!( |
|||
"Trying {} numbers instead of {} saves {:.2}%", |
|||
co9_candidates.len(), |
|||
naive_candidates.len(), |
|||
100.0 - 100.0 * (co9_candidates.len() as f64 / naive_candidates.len() as f64) |
|||
); |
|||
} |
|||
fn main() { |
<syntaxhighlight lang="rust">fn main() { |
||
let dog = "Benjamin"; |
|||
compare_co9_efficiency(10, 100); |
|||
let Dog = "Samba"; |
|||
compare_co9_efficiency(16, 256); |
|||
let DOG = "Bernie"; |
|||
println!("The three dogs are named {}, {} and {}.", dog, Dog, DOG); |
|||
}</syntaxhighlight> |
}</syntaxhighlight> |
||
This triggers two warnings at compilation: |
|||
{{out}} |
|||
<pre>1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
<syntaxhighlight lang="text"><anon>:3:9: 3:12 warning: variable `Dog` should have a snake case name such as `dog`, #[warn(non_snake_case)] on by default |
|||
Trying 22 numbers instead of 99 saves 77.78% |
|||
<anon>:3 let Dog = "Samba"; |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255 |
|||
^~~ |
|||
Trying 68 numbers instead of 255 saves 73.33%</pre> |
|||
<anon>:4:9: 4:12 warning: variable `DOG` should have a snake case name such as `dog`, #[warn(non_snake_case)] on by default |
|||
<anon>:4 let DOG = "Bernie"; |
|||
^~~</syntaxhighlight> |
|||
The resulting program will compile and run just fine, producing the output: |
|||
<syntaxhighlight lang="text">The three dogs are named Benjamin, Samba and Bernie.</syntaxhighlight> |
|||
=={{header|Sather}}== |
|||
Though by convention Sather uses all uppercase letters for class names, a variable can be |
|||
all uppercase. |
|||
<syntaxhighlight lang="sather">class MAIN is |
|||
main is |
|||
dog ::= "Benjamin"; |
|||
Dog ::= "Samba"; |
|||
DOG ::= "Bernie"; |
|||
#OUT + #FMT("The three dogs are %s, %s and %s\n", |
|||
dog, Dog, DOG); |
|||
end; |
|||
end;</syntaxhighlight> |
|||
Outputs: |
|||
<pre>The three dogs are Benjamin, Samba and Bernie</pre> |
|||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
<syntaxhighlight lang="scala">val dog = "Benjamin" |
|||
Code written in scala follows functional paradigm of programming, finds list of candidates for Kaprekar numbers within given range. |
|||
val Dog = "Samba" |
|||
<syntaxhighlight lang=Scala> |
|||
val DOG = "Bernie" |
|||
object kaprekar{ |
|||
println("There are three dogs named " + dog + ", " + Dog + ", and " + DOG + ".")</syntaxhighlight> |
|||
// PART 1 |
|||
Output: |
|||
val co_base = ((x:Int,base:Int) => (x%(base-1) == (x*x)%(base-1))) |
|||
<pre>There are three dogs named Benjamin, Samba, and Bernie.</pre> |
|||
//PART 2 |
|||
=={{header|Scheme}}== |
|||
def get_cands(n:Int,base:Int):List[Int] = { |
|||
Output may differ depending on implementation. |
|||
if(n==1) List[Int]() |
|||
<syntaxhighlight lang="scheme">(define dog "Benjamin") |
|||
else if (co_base(n,base)) n :: get_cands(n-1,base) |
|||
(define Dog "Samba") |
|||
else get_cands(n-1,base) |
|||
(define DOG "Bernie") |
|||
} |
|||
def main(args:Array[String]) : Unit = { |
|||
//PART 3 |
|||
val base = 31 |
|||
println("Candidates for Kaprekar numbers found by casting out method with base %d:".format(base)) |
|||
println(get_cands(1000,base)) |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Output for base 10 within range of 100: |
|||
Candidates for Kaprekar numbers found by casting out method with base 10: |
|||
List(100, 99, 91, 90, 82, 81, 73, 72, 64, 63, 55, 54, 46, 45, 37, 36, 28, 27, 19, 18, 10, 9) |
|||
Output for base 17 with range 1000: |
|||
Candidates for Kaprekar numbers found by casting out method with base 17: |
|||
List(993, 992, 977, 976, 961, 960, 945, 944, 929, 928, 913, 912, 897, 896, 881, 880, 865, 864, 849, 848, 833, 832, 817, 816, 801, 800, 785, 784, 769, 768, 753, 752, 737, 736, 721, 720, 705, 704, 689, 688, 673, 672, 657, 656, 641, 640, 625, 624, 609, 608, 593, 592, 577, 576, 561, 560, 545, 544, 529, 528, 513, 512, 497, 496, 481, 480, 465, 464, 449, 448, 433, 432, 417, 416, 401, 400, 385, 384, 369, 368, 353, 352, 337, 336, 321, 320, 305, 304, 289, 288, 273, 272, 257, 256, 241, 240, 225, 224, 209, 208, 193, 192, 177, 176, 161, 160, 145, 144, 129, 128, 113, 112, 97, 96, 81, 80, 65, 64, 49, 48, 33, 32, 17, 16) |
|||
</pre> |
|||
(if (eq? dog DOG) |
|||
(begin (display "There is one dog named ") |
|||
(display DOG) |
|||
(display ".") |
|||
(newline)) |
|||
(begin (display "The three dogs are named ") |
|||
(display dog) (display ", ") |
|||
(display Dog) (display " and ") |
|||
(display DOG) |
|||
(display ".") |
|||
(newline)))</syntaxhighlight> |
|||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
<syntaxhighlight lang=seed7>$ include "seed7_05.s7i"; |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
const string: dog is "Benjamin"; |
|||
const func bitset: castOut (in integer: base, in integer: start, in integer: ending) is func |
|||
const string: Dog is "Samba"; |
|||
result |
|||
const string: DOG is "Bernie"; |
|||
var bitset: casted is {}; |
|||
local |
|||
var bitset: ran is {}; |
|||
var integer: x is 0; |
|||
var integer: n is 0; |
|||
var integer: k is 0; |
|||
var boolean: finished is FALSE; |
|||
begin |
|||
for x range 0 to base - 2 do |
|||
if x rem pred(base) = x ** 2 rem pred(base) then |
|||
incl(ran, x); |
|||
end if; |
|||
end for; |
|||
x := start div pred(base); |
|||
repeat |
|||
for n range ran until finished do |
|||
k := pred(base) * x + n; |
|||
if k >= start then |
|||
if k > ending then |
|||
finished := TRUE; |
|||
else |
|||
incl(casted, k); |
|||
end if; |
|||
end if; |
|||
end for; |
|||
incr(x); |
|||
until finished; |
|||
end func; |
|||
const proc: main is func |
const proc: main is func |
||
begin |
begin |
||
writeln("The three dogs are named " <& dog <& ", " <& Dog <& " and " <& DOG <& "."); |
|||
writeln(castOut(16, 1, 255)); |
|||
end func;</syntaxhighlight> |
end func;</syntaxhighlight> |
||
=={{header|SenseTalk}}== |
|||
As a People Oriented Programming language, SenseTalk's variable names are case-insensitive. |
|||
<syntaxhighlight lang="sensetalk"> |
|||
set dog to "Benjamin" |
|||
set Dog to "Samba" |
|||
set DOG to "Bernie" |
|||
put !"There is just one dog named [[dog]]." |
|||
</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre>There is just one dog named Bernie.</pre> |
|||
<pre> |
|||
=={{header|SETL}}== |
|||
{1, 6, 10, 15, 16, 21, 25, 30, 31, 36, 40, 45, 46, 51, 55, 60, 61, 66, 70, 75, 76, 81, 85, 90, 91, 96, 100, 105, 106, 111, 115, 120, 121, 126, 130, 135, 136, 141, 145, 150, 151, 156, 160, 165, 166, 171, 175, 180, 181, 186, 190, 195, 196, 201, 205, 210, 211, 216, 220, 225, 226, 231, 235, 240, 241, 246, 250, 255} |
|||
<syntaxhighlight lang="pascal">dog := 'Benjamin'; |
|||
</pre> |
|||
Dog := 'Samba'; |
|||
DOG := 'Bernie'; |
|||
print( 'There is just one dog named', dOg );</syntaxhighlight> |
|||
{{out}} |
|||
<pre>There is just one dog named Bernie</pre> |
|||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
<syntaxhighlight lang="ruby">var dog = 'Benjamin'; |
|||
{{trans|Raku}} |
|||
var Dog = 'Samba'; |
|||
<syntaxhighlight lang=ruby>func cast_out(base = 10, min = 1, max = (base**2 - 1)) { |
|||
var DOG = 'Bernie'; |
|||
say "The three dogs are named #{dog}, #{Dog}, and #{DOG}.";</syntaxhighlight> |
|||
{{out}} |
|||
<pre>The three dogs are named Benjamin, Samba, and Bernie.</pre> |
|||
=={{header|Simula}}== |
|||
Simula identifiers are case-insensitive, and the compiler will indignantly reject a program that tries to declare multiple variables with names differing only in case. (Same with ''key words'': Case of a character in Simula ''code'' generally only matters in [http://simula67.at.ifi.uio.no/Standard-86/chap_1.htm| a simple string or a character constant].) |
|||
<syntaxhighlight lang="simula">begin |
|||
text dog; |
|||
dog :- blanks( 8 ); |
|||
dog := "Benjamin"; |
|||
Dog := "Samba"; |
|||
DOG := "Bernie"; |
|||
outtext( "There is just one dog, named " ); |
|||
outtext( dog ); |
|||
outimage |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre>There is just one dog, named Bernie</pre> |
|||
=={{header|Smalltalk}}== |
|||
{{works with|GNU Smalltalk}} |
|||
Smalltalk's symbols are case sensitive. |
|||
var b9 = base-1 |
|||
var ran = b9.range.grep {|n| n%b9 == (n*n % b9) } |
|||
<syntaxhighlight lang="smalltalk">|dog Dog DOG| |
|||
var x = min//b9 |
|||
dog := 'Benjamin'. |
|||
var r = [] |
|||
Dog := 'Samba'. |
|||
DOG := 'Bernie'. |
|||
( 'The three dogs are named %1, %2 and %3' % |
|||
{ dog . Dog . DOG } ) displayNl.</syntaxhighlight> |
|||
Outputs: |
|||
loop { |
|||
ran.each {|n| |
|||
var k = (b9*x + n) |
|||
return r if (k > max) |
|||
r << k if (k >= min) |
|||
} |
|||
++x |
|||
} |
|||
<pre>The three dogs are named Benjamin, Samba and Bernie</pre> |
|||
return r |
|||
=={{header|SNOBOL4}}== |
|||
} |
|||
<syntaxhighlight lang="snobol4"> DOG = 'Benjamin' |
|||
Dog = 'Samba' |
|||
say cast_out().join(' ') |
|||
dog = 'Bernie' |
|||
say cast_out(16).join(' ') |
|||
OUTPUT = 'The three dogs are named ' DOG ', ' Dog ', and ' dog |
|||
say cast_out(17).join(' ')</syntaxhighlight> |
|||
END</syntaxhighlight> |
|||
{{out}} |
|||
<pre>The three dogs are named Benjamin, Samba, and Bernie</pre> |
|||
=={{header|Standard ML}}== |
|||
Standard ML is case sensitive. |
|||
<syntaxhighlight lang="sml">let |
|||
val dog = "Benjamin" |
|||
val Dog = "Samba" |
|||
val DOG = "Bernie" |
|||
in |
|||
print("The three dogs are named " ^ dog ^ ", " ^ Dog ^ ", and " ^ DOG ^ ".\n") |
|||
end;</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre>The three dogs are named Benjamin, Samba, and Bernie.</pre> |
|||
<pre> |
|||
=={{header|Stata}}== |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
Stata is case-sensitive. |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255 |
|||
1 16 17 32 33 48 49 64 65 80 81 96 97 112 113 128 129 144 145 160 161 176 177 192 193 208 209 224 225 240 241 256 257 272 273 288 |
|||
</pre> |
|||
<syntaxhighlight lang="stata">. local dog Benjamin |
|||
. local Dog Samba |
|||
. local DOG Bernie |
|||
. display "The three dogs are named $_dog, $_Dog, and $_DOG." |
|||
The three dogs are named Benjamin, Samba, and Bernie.</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
<syntaxhighlight lang="swift">let dog = "Benjamin" |
|||
let Dog = "Samba" |
|||
let DOG = "Bernie" |
|||
println("The three dogs are named \(dog), \(Dog), and \(DOG).")</syntaxhighlight> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
Tcl variable names are case sensitive: |
|||
<syntaxhighlight lang=tcl>proc co9 {x} { |
|||
<syntaxhighlight lang="tcl">set dog "Benjamin" |
|||
while {[string length $x] > 1} { |
|||
set Dog "Samba" |
|||
set x [tcl::mathop::+ {*}[split $x ""]] |
|||
set DOG "Bernie" |
|||
} |
|||
puts "The three dogs are named $dog, $Dog and $DOG"</syntaxhighlight> |
|||
return $x |
|||
Which prints... |
|||
} |
|||
<pre>The three dogs are named Benjamin, Samba and Bernie</pre> |
|||
# Extended to the general case |
|||
=={{header|True BASIC}}== |
|||
proc coBase {x {base 10}} { |
|||
{{works with|QBasic}} |
|||
while {$x >= $base} { |
|||
True Basic is case-insensitive |
|||
for {set digits {}} {$x} {set x [expr {$x / $base}]} { |
|||
<syntaxhighlight lang="qbasic">LET dog$ = "Benjamin" |
|||
lappend digits [expr {$x % $base}] |
|||
LET Dog$ = "Samba" |
|||
} |
|||
LET DOG$ = "Bernie" |
|||
set x [tcl::mathop::+ {*}$digits] |
|||
PRINT "There is just one dog, named "; dog$ |
|||
} |
|||
END</syntaxhighlight> |
|||
return $x |
|||
=={{header|UNIX Shell}}== |
|||
} |
|||
<syntaxhighlight lang="sh">dog="Benjamin" |
|||
Dog="Samba" |
|||
DOG="Bernie" |
|||
echo "The three dogs are named $dog, $Dog and $DOG."</syntaxhighlight> |
|||
The three dogs are named Benjamin, Samba and Bernie. |
|||
# Simple helper |
|||
=={{header|Ursa}}== |
|||
proc percent {part whole} {format "%.2f%%" [expr {($whole - $part) * 100.0 / $whole}]} |
|||
Ursa names are case sensitive: |
|||
<syntaxhighlight lang="ursa">> decl string dog Dog DOG |
|||
> set dog "Benjamin" |
|||
> set Dog "Samba" |
|||
> set DOG "Bernie" |
|||
> out "The three dogs are named " dog ", " Dog ", and " DOG endl console |
|||
The three dogs are named Benjamin, Samba, and Bernie |
|||
></syntaxhighlight> |
|||
=={{header|VBA}}== |
|||
VBA is case sensitive case insensitive. The variable names 'dog', 'Dog' and 'DOG' can not co-exist. |
|||
<syntaxhighlight lang="vb">Public Sub case_sensitivity() |
|||
'VBA does not allow variables that only differ in case |
|||
'The VBA IDE vbe will rename variable 'dog' to 'DOG' |
|||
'when trying to define a second variable 'DOG' |
|||
Dim DOG As String |
|||
DOG = "Benjamin" |
|||
DOG = "Samba" |
|||
DOG = "Bernie" |
|||
Debug.Print "There is just one dog named " & DOG |
|||
End Sub</syntaxhighlight>{{out}} |
|||
<pre>There is just one dog named Bernie</pre> |
|||
=={{header|Wren}}== |
|||
Identifiers in Wren are case sensitive. |
|||
<syntaxhighlight lang="ecmascript">var dog = "Benjamin" |
|||
var Dog = "Samba" |
|||
var DOG = "Bernie" |
|||
System.print("The three dogs are named %(dog), %(Dog) and %(DOG).")</syntaxhighlight> |
|||
{{out}} |
|||
puts "In base 10..." |
|||
set satisfying {} |
|||
for {set i 1} {$i < 100} {incr i} { |
|||
if {[co9 $i] == [co9 [expr {$i*$i}]]} { |
|||
lappend satisfying $i |
|||
} |
|||
} |
|||
puts $satisfying |
|||
puts "Trying [llength $satisfying] numbers instead of 99 numbers saves [percent [llength $satisfying] 99]" |
|||
puts "In base 16..." |
|||
set satisfying {} |
|||
for {set i 1} {$i < 256} {incr i} { |
|||
if {[coBase $i 16] == [coBase [expr {$i*$i}] 16]} { |
|||
lappend satisfying $i |
|||
} |
|||
} |
|||
puts $satisfying |
|||
puts "Trying [llength $satisfying] numbers instead of 255 numbers saves [percent [llength $satisfying] 255]"</syntaxhighlight> |
|||
{{out}}With some newlines inserted… |
|||
<pre> |
<pre> |
||
The three dogs are named Benjamin, Samba and Bernie. |
|||
In base 10... |
|||
1 9 10 18 19 27 28 36 37 45 46 54 55 63 64 72 73 81 82 90 91 99 |
|||
Trying 22 numbers instead of 99 numbers saves 77.78% |
|||
In base 16... |
|||
1 6 10 15 16 21 25 30 31 36 40 45 46 51 55 60 61 66 70 75 76 81 85 90 91 96 100 |
|||
105 106 111 115 120 121 126 130 135 136 141 145 150 151 156 160 165 166 171 175 |
|||
180 181 186 190 195 196 201 205 210 211 216 220 225 226 231 235 240 241 246 250 255 |
|||
Trying 68 numbers instead of 255 numbers saves 73.33% |
|||
</pre> |
</pre> |
||
=={{header|XBS}}== |
|||
In XBS variable names are case-sensitive. |
|||
=={{header|Visual Basic .NET}}== |
|||
<syntaxhighlight lang="xbs">set dog="Benjamin"; |
|||
{{trans|Java}} |
|||
set DOG="Samba"; |
|||
<syntaxhighlight lang=vbnet>Module Module1 |
|||
set Dog="Bernie"; |
|||
Sub Print(ls As List(Of Integer)) |
|||
log(`The three dogs are named {dog}, {DOG} and {Dog}.`);</syntaxhighlight> |
|||
Dim iter = ls.GetEnumerator |
|||
Console.Write("[") |
|||
If iter.MoveNext Then |
|||
Console.Write(iter.Current) |
|||
End If |
|||
While iter.MoveNext |
|||
Console.Write(", ") |
|||
Console.Write(iter.Current) |
|||
End While |
|||
Console.WriteLine("]") |
|||
End Sub |
|||
Function CastOut(base As Integer, start As Integer, last As Integer) As List(Of Integer) |
|||
Dim ran = Enumerable.Range(0, base - 1).Where(Function(y) y Mod (base - 1) = (y * y) Mod (base - 1)).ToArray() |
|||
Dim x = start \ (base - 1) |
|||
Dim result As New List(Of Integer) |
|||
While True |
|||
For Each n In ran |
|||
Dim k = (base - 1) * x + n |
|||
If k < start Then |
|||
Continue For |
|||
End If |
|||
If k > last Then |
|||
Return result |
|||
End If |
|||
result.Add(k) |
|||
Next |
|||
x += 1 |
|||
End While |
|||
Return result |
|||
End Function |
|||
Sub Main() |
|||
Print(CastOut(16, 1, 255)) |
|||
Print(CastOut(10, 1, 99)) |
|||
Print(CastOut(17, 1, 288)) |
|||
End Sub |
|||
End Module</syntaxhighlight> |
|||
{{out}} |
|||
<pre>[1, 6, 10, 15, 16, 21, 25, 30, 31, 36, 40, 45, 46, 51, 55, 60, 61, 66, 70, 75, 76, 81, 85, 90, 91, 96, 100, 105, 106, 111, 115, 120, 121, 126, 130, 135, 136, 141, 145, 150, 151, 156, 160, 165, 166, 171, 175, 180, 181, 186, 190, 195, 196, 201, 205, 210, 211, 216, 220, 225, 226, 231, 235, 240, 241, 246, 250, 255] |
|||
[1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, 81, 82, 90, 91, 99] |
|||
[1, 16, 17, 32, 33, 48, 49, 64, 65, 80, 81, 96, 97, 112, 113, 128, 129, 144, 145, 160, 161, 176, 177, 192, 193, 208, 209, 224, 225, 240, 241, 256, 257, 272, 273, 288]</pre> |
|||
=={{header|Wren}}== |
|||
{{trans|D}} |
|||
<syntaxhighlight lang=ecmascript>var castOut = Fn.new { |base, start, end| |
|||
var b = base - 1 |
|||
var ran = (0...b).where { |n| n % b == (n * n) % b } |
|||
var x = (start/b).floor |
|||
var result = [] |
|||
while (true) { |
|||
for (n in ran) { |
|||
var k = b*x + n |
|||
if (k >= start) { |
|||
if (k > end) return result |
|||
result.add(k) |
|||
} |
|||
} |
|||
x = x + 1 |
|||
} |
|||
} |
|||
System.print(castOut.call(16, 1, 255)) |
|||
System.print() |
|||
System.print(castOut.call(10, 1, 99)) |
|||
System.print() |
|||
System.print(castOut.call(17, 1, 288))</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
The three dogs are named Benjamin, Samba and Bernie. |
|||
[1, 6, 10, 15, 16, 21, 25, 30, 31, 36, 40, 45, 46, 51, 55, 60, 61, 66, 70, 75, 76, 81, 85, 90, 91, 96, 100, 105, 106, 111, 115, 120, 121, 126, 130, 135, 136, 141, 145, 150, 151, 156, 160, 165, 166, 171, 175, 180, 181, 186, 190, 195, 196, 201, 205, 210, 211, 216, 220, 225, 226, 231, 235, 240, 241, 246, 250, 255] |
|||
[1, 9, 10, 18, 19, 27, 28, 36, 37, 45, 46, 54, 55, 63, 64, 72, 73, 81, 82, 90, 91, 99] |
|||
[1, 16, 17, 32, 33, 48, 49, 64, 65, 80, 81, 96, 97, 112, 113, 128, 129, 144, 145, 160, 161, 176, 177, 192, 193, 208, 209, 224, 225, 240, 241, 256, 257, 272, 273, 288] |
|||
</pre> |
</pre> |
||
=={{header|XLISP}}== |
|||
XLISP is entirely case-insensitive. The user can decide whether to have the system print symbols, etc., in capitals or in lower case, by assigning to the variable <tt>*PRINT-CASE*</tt>. |
|||
<syntaxhighlight lang="xlisp">(SETQ DOG 'BENJAMIN) |
|||
(SETQ Dog 'SAMBA) |
|||
(SETQ dog 'BERNIE) |
|||
(DISPLAY `(THERE IS JUST ONE DOG NAMED ,DOG))</syntaxhighlight> |
|||
There is, in any event, only one dog. |
|||
<pre>(THERE IS JUST ONE DOG NAMED BERNIE)</pre> |
|||
=={{header|XPL0}}== |
|||
XPL0 is normally case-insensitive, so there is really just one dog named |
|||
Bernie. However, it has a command-line switch (/c) that turns case |
|||
sensitivity on. All names must start with a capital letter (or an underline, so they can't |
|||
clash with command words such as 'for'). Thus "dog" cannot be used as a |
|||
name, but Dog, DOG and DoG (and For) can. The intent of the command-line |
|||
switch (/c) is to detect inconsistent capitalizing of names such as |
|||
Ascii and ASCII or CpuReg and CPUReg. |
|||
=={{header|Yabasic}}== |
|||
Yabasic names are case sensitive: |
|||
<syntaxhighlight lang="yabasic"> |
|||
dog$ = "Benjamin" |
|||
Dog$ = "Samba" |
|||
DOG$ = "Bernie" |
|||
print "The three dogs are named ", dog$, ", ", Dog$, " and ", DOG$ |
|||
end</syntaxhighlight> |
|||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
<syntaxhighlight lang="zkl">var dog = "Benjamin", Dog = "Samba", DOG = "Bernie";</syntaxhighlight> |
|||
{{trans|D}} |
|||
<syntaxhighlight lang=zkl>fcn castOut(base=10, start=1, end=999999){ |
|||
base-=1; |
|||
ran:=(0).filter(base,'wrap(n){ n%base == (n*n)%base }); |
|||
result:=Sink(List); |
|||
foreach a,b in ([start/base ..],ran){ // foreach{ foreach {} } |
|||
k := base*a + b; |
|||
if (k < start) continue; |
|||
if (k > end) return(result.close()); |
|||
result.write(k); |
|||
} |
|||
// doesn't get here |
|||
}</syntaxhighlight> |
|||
<syntaxhighlight lang=zkl>castOut(16, 1, 255).toString(*).println("\n-----"); |
|||
castOut(10, 1, 99).toString(*).println("\n-----"); |
|||
castOut(17, 1, 288).toString(*).println();</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
vars |
|||
L(1,6,10,15,16,21,25,30,31,36,40,45,46,51,55,60,61,66,70,75, |
|||
L(L("DOG","Bernie"),L("Dog","Samba"),L("dog","Benjamin")) |
|||
76,81,85,90,91,96,100,105,106,111,115,120,121,126,130,135,136, |
|||
141,145,150,151,156,160,165,166,171,175,180,181,186,190,195,196, |
|||
201,205,210,211,216,220,225,226,231,235,240,241,246,250,255) |
|||
----- |
|||
L(1,9,10,18,19,27,28,36,37,45,46,54,55,63,64,72,73,81,82,90,91,99) |
|||
----- |
|||
L(1,16,17,32,33,48,49,64,65,80,81,96,97,112,113,128, |
|||
129,144,145,160,161,176,177,192,193,208,209,224,225,240, |
|||
241,256,257,272,273,288) |
|||
</pre> |
</pre> |
||
=={{header|ZX Spectrum Basic}}== |
=={{header|ZX Spectrum Basic}}== |
||
<syntaxhighlight lang="basic">10 LET D$="Benjamin" |
|||
{{trans|C++}} |
|||
20 PRINT "There is just one dog named ";d$</syntaxhighlight> |
|||
<syntaxhighlight lang=zxbasic>10 LET Base=10 |
|||
{{omit from|360 Assembly}} |
|||
20 LET N=2 |
|||
{{omit from|6502 Assembly|Depends on assembler. Some have a -nocase command line argument that ignores sensitivity of labels.}} |
|||
30 LET c1=0 |
|||
{{omit from|8051 Assembly}} |
|||
40 LET c2=0 |
|||
{{omit from|8080 Assembly}} |
|||
50 LET k=1 |
|||
{{omit from|8086 Assembly}} |
|||
60 IF k>=(Base^N)-1 THEN GO TO 150 |
|||
{{omit from|68000 Assembly}} |
|||
70 LET c1=c1+1 |
|||
{{omit from|AArch64 Assembly}} |
|||
80 IF FN m(k,Base-1)=FN m(k*k,Base-1) THEN LET c2=c2+1: PRINT k;" "; |
|||
{{omit from|ARM Assembly}} |
|||
90 LET k=k+1 |
|||
{{omit from|MIPS Assembly}} |
|||
100 GO TO 60 |
|||
{{omit from|sed|No variables.}} |
|||
150 PRINT '"Trying ";c2;" numbers instead of ";c1;" numbers saves ";100-(c2/c1)*100;"%" |
|||
{{omit from|x86 Assembly}} |
|||
160 STOP |
|||
{{omit from|Z80 Assembly}} |
|||
170 DEF FN m(a,b)=a-INT (a/b)*b |
|||
</syntaxhighlight> |
|||
{{omit from|GUISS}} |
Revision as of 22:46, 30 August 2022
You are encouraged to solve this task according to the task description, using any language you may know.
Three dogs (Are there three dogs or one dog?) is a code snippet used to illustrate the lettercase sensitivity of the programming language. For a case-sensitive language, the identifiers dog, Dog and DOG are all different and we should get the output:
The three dogs are named Benjamin, Samba and Bernie.
For a language that is lettercase insensitive, we get the following output:
There is just one dog named Bernie.
- Related task
11l
11l identifiers are case sensitive.
V dog = ‘Benjamin’
V Dog = ‘Samba’
V DOG = ‘Bernie’
print(‘The three dogs are named ’dog‘, ’Dog‘ and ’DOG‘.’)
Action!
PROC Main()
CHAR ARRAY dog="Bernie"
PrintF("There is just one dog named %S.",dog)
RETURN
- Output:
Screenshot from Atari 8-bit computer
There is just one dog named Bernie.
Ada
case insensitive
with Ada.Text_IO;
procedure Dogs is
Dog : String := "Bernie";
begin
Ada.Text_IO.Put_Line ("There is just one dog named " & DOG);
end Dogs;
Output:
There is just one dog named Bernie
Agena
Translation of Algol W. Agena is case sensitive, as this example demonstrates. Tested with Agena 2.9.5 Win32
scope
local dog := "Benjamin";
scope
local Dog := "Samba";
scope
local DOG := "Bernie";
if DOG <> Dog or DOG <> dog
then print( "The three dogs are named: " & dog & ", " & Dog & " and " & DOG )
else print( "There is just one dog named: " & DOG )
fi
epocs
epocs
epocs
- Output:
The three dogs are named: Benjamin, Samba and Bernie
Aime
text dog, Dog, DOG;
dog = "Benjamin";
Dog = "Samba";
DOG = "Bernie";
o_form("The three dogs are named ~, ~ and ~.\n", dog, Dog, DOG);
ALGOL 68
A joke code entry... :-) ¢ but the code does actually work!
File: Case-sensitivity_of_identifiers.a68
#!/usr/bin/a68g --script #
# -*- coding: utf-8 -*- #
STRING dog = "Benjamin";
OP D = (INT og)STRING: "Samba";
OP DOG = (INT gy)STRING: "Bernie";
INT og=~, gy=~;
main:(
printf(($"The three dogs are named "g", "g" and "g"."l$, dog, Dog, DOGgy));
0
)
Output:
The three dogs are named Benjamin, Samba and Bernie.
Alternative version.
Most recent implementations of Algol 68 use "upper stropping", the "keywords" are in upper case and the identifiers are an lower case. This precludes use of e.g. Dog or DOG as the name of a variable or constant.
However, depending on the "stropping" convention used and the implementation, Algol 68 can be case-sensitive. Rutgers ALGOL 68 uses quote stropping and allows both upper and lower case in identifiers and bold words. The standard bold words must be in lower-case.
'begin'
'string' dog = "Benjamin";
'begin'
'string' Dog = "Samba";
'begin'
'string' DOG = "Bernie";
'if' DOG /= Dog 'or' DOG /= dog
'then' print( ( "The three dogs are named: ", dog, ", ", Dog, " and ", DOG ) )
'else' print( ( "There is just one dog named: ", DOG ) )
'fi'
'end'
'end'
'end'
- Output:
The three dogs are named: Benjamin, Samba and Bernie
ALGOL W
Algol W identifiers are not case-sensitive but variable names in inner blocks can be the same as those in outer blocks...
begin
string(8) dog;
dog := "Benjamin";
begin
string(8) Dog;
Dog := "Samba";
begin
string(8) DOG;
DOG := "Bernie";
if DOG not = Dog
or DOG not = dog
then write( "The three dogs are named: ", dog, ", ", Dog, " and ", DOG )
else write( "There is just one dog named: ", DOG )
end
end
end.
- Output:
There is just one dog named: Bernie
APL
DOG←'Benjamin'
Dog←'Samba'
dog←'Bernie'
'The three dogs are named ',DOG,', ',Dog,', and ',dog
The three dogs are named Benjamin, Samba, and Bernie
Arturo
dog: "Benjamin"
Dog: "Samba"
DOG: "Bernie"
dogs: @[dog Dog DOG]
print ["The" size dogs "dog(s) are named" join.with:", " dogs]
- Output:
The 3 dog(s) are named Benjamin, Samba, Bernie
AutoHotkey
dog := "Benjamin"
Dog := "Samba"
DOG := "Bernie"
MsgBox There is just one dog named %dOG%
AWK
BEGIN {
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
printf "The three dogs are named %s, %s and %s.\n", dog, Dog, DOG
}
The three dogs are named Benjamin, Samba and Bernie.
BASIC
QBASIC is case-insensitive
DOG$ = "Benjamin"
DOG$ = "Samba"
DOG$ = "Bernie"
PRINT "There is just one dog, named "; DOG$
BASIC256
BASIC256 is case-insensitive
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
print "There is just one dog, named "; dog
end
Batch File
@echo off
set dog=Benjamin
set Dog=Samba
set DOG=Bernie
echo There is just one dog named %dog%.
pause>nul
- Output:
There is just one dog named Bernie.
BBC BASIC
dog$ = "Benjamin"
Dog$ = "Samba"
DOG$ = "Bernie"
PRINT "The three dogs are " dog$ ", " Dog$ " and " DOG$ "."
Output:
The three dogs are Benjamin, Samba and Bernie.
bc
The only variables are 'a' through 'z'. They can only hold numbers, not strings. Some implementations allow longer names like 'dog', but only with lowercase letters. A name like 'Dog' or 'DOG' is a syntax error.
obase = 16
ibase = 16
/*
* Store the hexadecimal number 'BE27A312'
* in the variable 'd'.
*/
d = BE27A312
"There is just one dog named "; d
quit
There is just one dog named BE27A312
Bracmat
( Benjamin:?dog
& Samba:?Dog
& Bernie:?DOG
& out$("There are three dogs:" !dog !Dog and !DOG)
);
Output:
There are three dogs: Benjamin Samba and Bernie
Brlcad
The three dogs are drawn as spheres in this simple example:
opendb dogs.g y # Create a database to hold our dogs
units ft # The dogs are measured in feet
in dog.s sph 0 0 0 1 # Benjie is a little Scottie dog
in Dog.s sph 4 0 0 3 # Samba is a Labrador
in DOG.s sph 13 0 0 5 # Bernie is massive. He is a New Foundland
echo The three dogs are named Benjamin, Samba and Bernie
C
C is case sensitive; if it would be case insensitive, an error about redefinition of a variable would be raised.
#include <stdio.h>
static const char *dog = "Benjamin";
static const char *Dog = "Samba";
static const char *DOG = "Bernie";
int main()
{
printf("The three dogs are named %s, %s and %s.\n", dog, Dog, DOG);
return 0;
}
C#
C# is case sensitive
using System;
class Program
{
static void Main(string[] args)
{
string dog = "Benjamin";
string Dog = "Samba";
string DOG = "Bernie";
Console.WriteLine(string.Format("The three dogs are named {0}, {1}, and {2}.", dog, Dog, DOG));
}
}
C++
C++ is case-sensitive.
#include <iostream>
#include <string>
using namespace std;
int main() {
string dog = "Benjamin", Dog = "Samba", DOG = "Bernie";
cout << "The three dogs are named " << dog << ", " << Dog << ", and " << DOG << endl;
}
- Output:
The three dogs are named Benjamin, Samba, and Bernie
Clojure
user=> (let [dog "Benjamin" Dog "Samba" DOG "Bernie"] (format "The three dogs are named %s, %s and %s." dog Dog DOG)) "The three dogs are named Benjamin, Samba and Bernie."
COBOL
* Case sensitivity of identifiers
*>* Commented-out lines in the working storage
*>* are considered as invalid redefinitions
*>* of ''dog'' that can only be ambiguously
*>* referenced in the procedure body.
IDENTIFICATION DIVISION.
PROGRAM-ID. case-sensitivity.
DATA DIVISION.
WORKING-STORAGE SECTION.
*>* 01 dog PICTURE X(8) VALUE IS "Benjamin".
*>* 01 Dog PICTURE X(5) VALUE IS "Samba".
01 DOG PICTURE X(6) VALUE IS "Bernie".
PROCEDURE DIVISION.
DISPLAY
*>* "The three dogs are named "
*>* dog ", " Dog " and " DOG "."
"There is just one dog named " DOG "."
END-DISPLAY
STOP RUN.
END PROGRAM case-sensitivity.
CoffeeScript
dog="Benjamin"
Dog = "Samba"
DOG = "Bernie"
console.log "The three dogs are names #{dog}, #{Dog}, and #{DOG}."
output
> coffee foo.coffee
The three dogs are names Benjamin, Samba, and Bernie.
Common Lisp
CL-USER> (let* ((dog "Benjamin") (Dog "Samba") (DOG "Bernie"))
(format nil "There is just one dog named ~a." dog))
; in: LAMBDA NIL
; (LET* ((DOG "Benjamin") (DOG "Samba") (DOG "Bernie"))
; (FORMAT NIL "There is just one dog named ~a." DOG))
;
; caught STYLE-WARNING:
; The variable DOG is defined but never used.
;
; caught STYLE-WARNING:
; The variable DOG is defined but never used.
;
; compilation unit finished
; caught 2 STYLE-WARNING conditions
"There is just one dog named Bernie."
These are the style warnings from SBCL. Other implementations of Common Lisp might give different warnings.
Crystal
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
puts "The three dogs are named #{dog}, #{Dog} and #{DOG}."
Note that in Crystal, variables with all-caps identifiers (like DOG
) are always constants.
- Output:
The three dogs are named Benjamin, Samba and Bernie.
D
import std.stdio;
void main() {
string dog = "Benjamin";
// identifiers that start with capital letters are type names
string Dog = "Samba";
string DOG = "Bernie";
writefln("There are three dogs named ",
dog, ", ", Dog, ", and ", DOG, "'");
}
Output:
There are three dogs named Benjamin, Samba, and Bernie'
dc
A register name has only one character, so this example uses 'd' and 'D'.
[Benjamin]sd
[Samba]sD
[The two dogs are named ]P ldP [ and ]P lDP [.
]P
- Output:
The two dogs are named Benjamin and Samba.
Delphi
Delphi is case insensitive.
program CaseSensitiveIdentifiers;
{$APPTYPE CONSOLE}
var
dog: string;
begin
dog := 'Benjamin';
Dog := 'Samba';
DOG := 'Bernie';
Writeln('There is just one dog named ' + dog);
end.
Output:
There is just one dog named Bernie
DWScript
var dog : String;
dog := 'Benjamin';
Dog := 'Samba';
DOG := 'Bernie';
PrintLn('There is just one dog named ' + dog);
Output:
There is just one dog named Bernie
Déjà Vu
local :dog "Benjamin"
local :Dog "Samba"
local :DOG "Bernie"
!print( "There are three dogs named " dog ", " Dog " and " DOG "." )
- Output:
There are three dogs named Benjamin, Samba and Bernie.
EchoLisp
(define dog "Benjamin")
(define Dog "Samba")
(define DOG "Bernie")
(printf "The three dogs are named %a, %a and %a. " dog Dog DOG)
The three dogs are named Benjamin, Samba and Bernie.
Elena
In ELENA identifiers are case sensitive. ELENA 4.x:
import extensions;
public program()
{
var dog := "Benjamin";
var Dog := "Samba";
var DOG := "Bernie";
console.printLineFormatted("The three dogs are named {0}, {1} and {2}", dog, Dog, DOG)
}
- Output:
The three dogs are named Benjamin, Samba and Bernie
Elixir
While Elixir's identifiers are case-sensitive, they generally must start with a lowercase letter. Capitalized identifiers are reserved for modules.
dog = "Benjamin"
doG = "Samba"
dOG = "Bernie"
IO.puts "The three dogs are named #{dog}, #{doG} and #{dOG}."
- Output:
The three dogs are named Benjamin, Samba and Bernie.
Erlang
Erlang variables are case sensitive but must start with an uppercase letter.
-module( case_sensitivity_of_identifiers ).
-export( [task/0] ).
task() ->
catch dog = "Benjamin", % Function will crash without catch
Dog = "Samba",
DOG = "Bernie",
io:fwrite( "The three dogs are named ~s, ~s and ~s~n", [dog, Dog, DOG] ).
- Output:
4> case_sensitivity_of_identifiers:task(). The three dogs are named dog, Samba and Bernie
Euphoria
-- These variables are all different
sequence dog = "Benjamin"
sequence Dog = "Samba"
sequence DOG = "Bernie"
printf( 1, "The three dogs are named %s, %s and %s\n", {dog, Dog, DOG} )
F#
F# is case-sensitive.
let dog = "Benjamin"
let Dog = "Samba"
let DOG = "Bernie"
printfn "There are three dogs named %s, %s and %s" dog Dog DOG
Factor
Factor identifiers are case-sensitive.
USING: formatting locals ;
IN: scratchpad
[let
"Benjamin" :> dog
"Samba" :> Dog
"Bernie" :> DOG
{ dog Dog DOG } "There are three dogs named %s, %s, and %s." vprintf
]
- Output:
There are three dogs named Benjamin, Samba, and Bernie.
Forth
: DOG ." Benjamin" ;
: Dog ." Samba" ;
: dog ." Bernie" ;
: HOWMANYDOGS ." There is just one dog named " DOG ;
HOWMANYDOGS
- Output:
There is just one dog named Bernie
Fortran
Fortran is case insensitive, and so the three "dog" variants name the same variable - which therefore is multiply declared and will likely evoke a compiler complaint.
program Example
implicit none
character(8) :: dog, Dog, DOG
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
if (dog == DOG) then
write(*,*) "There is just one dog named ", dog
else
write(*,*) "The three dogs are named ", dog, Dog, " and ", DOG
end if
end program Example
Output:
There is just one dog named Bernie
FreeBASIC
' FB 1.05.0 Win64
' FreeBASIC is case-insensitive
Dim dog As String
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
Print "There is just one dog, named "; dog
Sleep
- Output:
There is just one dog, named Bernie
Frink
Frink is case-sensitive.
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
println["There are three dogs named $dog, $Dog and $DOG"]
Gambas
Click this link to run this code
Gambas in case insensitive
Public Sub Main()
Dim dog As String
Dog = "Benjamin"
DOG = "Samba"
dog = "Bernie"
Print "There is just one dog, named "; dog
End
Output:
There is just one dog, named Bernie
GAP
# GAP is case sensitive
ThreeDogs := function()
local dog, Dog, DOG;
dog := "Benjamin";
Dog := "Samba";
DOG := "Bernie";
if dog = DOG then
Print("There is just one dog named ", dog, "\n");
else
Print("The three dogs are named ", dog, ", ", Dog, " and ", DOG, "\n");
fi;
end;
ThreeDogs();
# The three dogs are named Benjamin, Samba and Bernie
Go
Go is case sensitive. Further, visibility depends on case. See the Go entry under the Scope modifiers task.
package dogs
import "fmt"
// Three variables, three different names.
// (It wouldn't compile if the compiler saw the variable names as the same.)
var dog = "Salt"
var Dog = "Pepper"
var DOG = "Mustard"
func PackageSees() map[*string]int {
// Print dogs visible from here.
fmt.Println("Package sees:", dog, Dog, DOG)
// Return addresses of the variables visible from here.
// The point of putting them in a map is that maps store only
// unique keys, so it will end up with three items only if
// the variables really represent different places in memory.
return map[*string]int{&dog: 1, &Dog: 1, &DOG: 1}
}
package main
import (
. "dogs"
"fmt"
)
func main() {
// with the dogs package imported, there are three dogs.
d := PackageSees()
fmt.Println("There are", len(d), "dogs.\n")
// Declaration of new variable dog. It lives in this package, main.
dog := "Benjamin"
d = PackageSees()
fmt.Println("Main sees: ", dog, Dog, DOG)
// Four dogs now. two of the three visible from here are the
// the same as ones in the dogs package.
d[&dog] = 1
d[&Dog] = 1
d[&DOG] = 1
fmt.Println("There are", len(d), "dogs.\n")
// Not a declaration, just an assigment. This assigns a new value to
// the variable Dog declared in the package. Dog is visible because
// it begins with an upper case letter.
Dog = "Samba"
// same four dogs, same three visible, one just has a new name.
d = PackageSees()
fmt.Println("Main sees: ", dog, Dog, DOG)
d[&dog] = 1
d[&Dog] = 1
d[&DOG] = 1
fmt.Println("There are", len(d), "dogs.\n")
// Of course you can still declare a variable if you want to. This
// declares a new variable, shadowing DOG in the package and rendering
// it inaccessable even though it begins with an upper case letter.
var DOG = "Bernie"
// five dogs now. three visible from here.
d = PackageSees()
fmt.Println("Main sees: ", dog, Dog, DOG)
d[&dog] = 1
d[&Dog] = 1
d[&DOG] = 1
fmt.Println("There are", len(d), "dogs.")
}
- Output:
Package sees: Salt Pepper Mustard There are 3 dogs. Package sees: Salt Pepper Mustard Main sees: Benjamin Pepper Mustard There are 4 dogs. Package sees: Salt Samba Mustard Main sees: Benjamin Samba Mustard There are 4 dogs. Package sees: Salt Samba Mustard Main sees: Benjamin Samba Bernie There are 5 dogs.
Groovy
Solution:
def dog = "Benjamin", Dog = "Samba", DOG = "Bernie"
println (dog == DOG ? "There is one dog named ${dog}" : "There are three dogs named ${dog}, ${Dog} and ${DOG}.")
Output:
There are three dogs named Benjamin, Samba and Bernie.
Haskell
Identifiers are case sensitive in Haskell, but must start with a lower case letter.
import Text.Printf
main = printf "The three dogs are named %s, %s and %s.\n" dog dOG dOg
where dog = "Benjamin"
dOG = "Samba"
dOg = "Bernie"
Icon and Unicon
The program below demonstrates the three dog task. All variants of Icon/Unicon have case sensitive variable names. But if one wasn't this would find it.
J
NB. These variables are all different
dog=: 'Benjamin'
Dog=: 'Samba'
DOG=: 'Bernie'
'The three dogs are named ',dog,', ',Dog,', and ',DOG
The three dogs are named Benjamin, Samba, and Bernie
Java
String dog = "Benjamin";
String Dog = "Samba"; //in general, identifiers that start with capital letters are class names
String DOG = "Bernie"; //in general, identifiers in all caps are constants
//the conventions listed in comments here are not enforced by the language
System.out.println("There are three dogs named " + dog + ", " + Dog + ", and " + DOG + "'");
JavaScript
Javascript is case sensitive.
var dog = "Benjamin";
var Dog = "Samba";
var DOG = "Bernie";
document.write("The three dogs are named " + dog + ", " + Dog + ", and " + DOG + ".");
jq
jq identifiers are case-sensitive.
Function parameters:
def task(dog; Dog; DOG):
"The three dogs are named \(dog), \(Dog), and \(DOG)." ;
task("Benjamin"; "Samba"; "Bernie")
- Output:
$ jq -n -f Case-sensitivity.jq "The three dogs are named Benjamin, Samba, and Bernie."
Variable names:
"Benjamin" as $dog | "Samba" as $Dog | "Bernie" as $DOG
| "The three dogs are named \($dog), \($Dog), and \($DOG)."
- Output:
As above.
Julia
Variable names are case sensitive.
dog, Dog, DOG = "Benjamin", "Samba", "Bernie"
if dog === Dog
println("There is only one dog, ", DOG)
else
println("The three dogs are: ", dog, ", ", Dog, " and ", DOG)
end
- Output:
The three dogs are: Benjamin, Samba and Bernie
Conventionally, variable names should be all lower case. Type and Macro names should be capitalized.
K
dog: "Benjamin"
Dog: "Samba"
DOG: "Bernie"
"There are three dogs named ",dog,", ",Dog," and ",DOG
"There are three dogs named Benjamin, Samba and Bernie"
Kotlin
Kotlin is case-sensitive though (as in Java) the convention is for local variable names to begin with a lower case letter. The second and third identifiers would therefore be unlikely to be used in practice.
fun main(args: Array<String>) {
val dog = "Benjamin"
val Dog = "Samba"
val DOG = "Bernie"
println("The three dogs are named $dog, $Dog and $DOG")
}
- Output:
The three dogs are named Benjamin, Samba and Bernie
Lasso
Lasso is not case sensitive for names
local(dog = 'Benjamin')
local(Dog = 'Samba')
local(DOG = 'Bernie')
stdoutnl('There is just one dog named ' + #dog)
Output:
There is just one dog named Bernie
Same with string comparisons. (Lasso maps can only contain unique keys)
local(dogs = map(
'dog' = 'Benjamin',
'Dog' = 'Samba',
'DOG' = 'Bernie'
))
stdoutnl(#dogs -> size)
Output:
1
To get case sensitivity we need to use bytes
local(dogs = map(
bytes('dog') = 'Benjamin',
bytes('Dog') = 'Samba',
bytes('DOG') = 'Bernie'
))
stdoutnl(#dogs -> size)
stdoutnl(#dogs -> find(bytes('Dog')))
Output:
3 Samba
Liberty BASIC
NB the IDE warns you that there are similar variables named dog$, Dog$ & DOG$
dog$ = "Benjamin"
Dog$ = "Samba"
DOG$ = "Bernie"
print "The three dogs are "; dog$; ", "; Dog$; " and "; DOG$; "."
end
The three dogs are Benjamin, Samba and Bernie.
Lua
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
print( "There are three dogs named "..dog..", "..Dog.." and "..DOG.."." )
There are three dogs named Benjamin, Samba and Bernie.
M2000 Interpreter
Labels are case sensitive, but identifiers are not case sensitive. Keys in Inventory are case sensitive Types in Enumeration are case sensitive, identifiers are not case sensitive.
MoDuLe CheckIT {
\\ keys as case sensitive if they are strings
Inventory A= "Dog":=1, "dog":=2,"DOG":="Hello", 100:="Dog"
Print A("Dog"), A("dog"), A$("DOG"), A$(100)
\\ Enumeration get type as defined (same case)
Enum Dogs {Benjamin, Samba, Bernie}
Print Type$(Bernie)="Dogs"
Print Type$(DOGS)="Dogs"
m=BenJamiN
m++
Print Eval$(m)="Samba" ' same case as defined
DoG$="Benjamin"
DOG$="Samba"
doG$="Bernie"
PrinT "There is just one dog named "+Dog$+"."
goto Dog
dog:
Print "dog"
Exit
Dog:
Print "Dog"
GoTo dog
}
Checkit
Maple
> dog, Dog, DOG := "Benjamin", "Samba", "Bernie":
> if nops( { dog, Dog, DOG } ) = 3 then
> printf( "There are three dogs named %s, %s and %s.\n", dog, Dog, DOG )
> elif nops( { dog, Dog, DOG } ) = 2 then
> printf( "WTF? There are two dogs named %s and %s.\n", op( { dog, Dog, DOG } ) )
> else
> printf( "There is one dog named %s.\n", dog )
> end if:
There are three dogs named Benjamin, Samba and Bernie.
Mathematica / Wolfram Language
dog = "Benjamin"; Dog = "Samba"; DOG = "Bernie";
"The three dogs are named "<> dog <>", "<> Dog <>" and "<> DOG
-> "The three dogs are named Benjamin, Samba and Bernie"
MATLAB / Octave
dog = 'Benjamin';
Dog = 'Samba';
DOG = 'Bernie';
printf('There are three dogs %s, %s, %s.\n',dog, Dog, DOG);
Output
There are three dogs Benjamin, Samba, Bernie.
Maxima
/* Maxima is case sensitive */
a: 1$
A: 2$
is(a = A);
false
min
min's symbols are case sensitive.
"Benjamin" :dog
"Samba" :Dog
"Bernie" :DOG
"There are three dogs named $1, $2, and $3." (dog Dog DOG)=> % print
- Output:
There are three dogs named Benjamin, Samba, and Bernie.
MiniScript
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
print "There are three dogs named " + dog + ", " + Dog + " and " + DOG
Modula-2
MODULE dog;
IMPORT InOut;
TYPE String = ARRAY [0..31] OF CHAR;
VAR dog, Dog, DOG : String;
(* No compiler error, so the rest is simple *)
BEGIN
InOut.WriteString ("Three happy dogs.");
InOut.WriteLn
END dog.
Nanoquery
dog = "Benjamin"
Dog = "Samba"
DOG = "Bernie"
print format("The three dogs are named %s, %s, and %s.\n", dog, Dog, DOG)
- Output:
The three dogs are named Benjamin, Samba, and Bernie.
Nemerle
def dog = "Benjamin";
def Dog = "Samba";
def DOG = "Bernie";
WriteLine($"The three dogs are named $dog, $Dog, and $DOG");
NESL
NESL is completely case-insensitive.
dog = "Benjamin";
Dog = "Samba";
DOG = "Bernie";
"There is just one dog, named " ++ dog;
- Output:
it = "There is just one dog, named Bernie" : [char]
NetRexx
NetRexx is not case sensitive:
/* NetRexx */
options replace format comments java crossref symbols nobinary
dog = "Benjamin";
Dog = "Samba";
DOG = "Bernie";
if dog == Dog & Dog == DOG & dog == DOG then do
say 'There is just one dog named' dog'.'
end
else do
say 'The three dogs are named' dog',' Dog 'and' DOG'.'
end
return
Output:
There is just one dog named Bernie.
Nim
Nim has peculiar rules regarding case and style sensitivity:
- – it is mainly a case insensitive language;
- – but keywords are all in lowercase;
- – and the first letter of an identifier is case sensitive;
- – moreover, underline is ignored in identifiers (style insensitivity).
With these rules, we don’t get one dog or three dogs: we get two dogs!
var dog, Dog: string
(dog, Dog, DOG) = ("Benjamin", "Samba", "Bernie")
if dog == Dog:
if dog == DOG:
echo "There is only one dog, ", DOG)
else:
echo "There are two dogs: ", dog, " and ", DOG
elif Dog == DOG :
echo "There are two dogs: ", dog, " and ", DOG
else:
echo "There are three dogs: ", dog, ", ", Dog, " and ", DOG
- Output:
There are two dogs: Benjamin and Bernie
Oberon-2
MODULE CaseSensitivity;
IMPORT
Out;
VAR
dog, Dog, DOG: STRING;
BEGIN
dog := "Benjamin";
Dog := "Samba";
DOG := "Bernie";
Out.Object("The three dogs are named " + dog + ", " + Dog + " and " + DOG);
Out.Ln
END CaseSensitivity.
- Output:
The three dogs are named Benjamin, Samba and Bernie
Objeck
Objeck is case sensitive
class Program {
function : Main(args : String[]) ~ Nil {
dog := "Benjamin";
Dog := "Samba";
DOG := "Bernie";
"The three dogs are named {$dog}, {$Dog}, and {$DOG}."->PrintLine();
}
}
OCaml
Identifiers in OCaml are lettercase sensitive, but the first letter has to be lowercase.
let () =
let dog = "Benjamin" in
let dOG = "Samba" in
let dOg = "Bernie" in
Printf.printf "The three dogs are named %s, %s and %s.\n" dog dOG dOg
Oforth
Oforth is case-sensitive.
: threeDogs
| dog Dog DOG |
"Benjamin" ->dog
"Samba" ->Dog
"Bernie" ->DOG
System.Out "The three dogs are named " << dog << ", " << Dog << " and " << DOG << "." << cr ;
Ol
(define dog "Benjamin")
(define Dog "Samba")
(define DOG "Bernie")
(print "The three dogs are named " dog ", " Dog " and " DOG ".\n")
- Output:
The three dogs are named Benjamin, Samba and Bernie.
PARI/GP
dog="Benjamin";
Dog="Samba";
DOG="Bernie";
printf("The three dogs are named %s, %s, and %s.", dog, Dog, DOG)
Pascal
See Delphi
Perl
# These variables are all different
$dog='Benjamin';
$Dog='Samba';
$DOG='Bernie';
print "The three dogs are named $dog, $Dog, and $DOG \n"
Phix
Phix is case sensitive
sequence dog = "Benjamin", Dog = "Samba", DOG = "Bernie" printf( 1, "The three dogs are named %s, %s and %s\n", {dog, Dog, DOG} )
- Output:
The three dogs are named Benjamin, Samba and Bernie
PicoLisp
(let (dog "Benjamin" Dog "Samba" DOG "Bernie")
(prinl "The three dogs are named " dog ", " Dog " and " DOG) )
Output:
The three dogs are named Benjamin, Samba and Bernie
PL/I
*process or(!) source xref attributes macro options;
/*********************************************************************
* Program to show that PL/I is case-insensitive
* 28.05.2013 Walter Pachl
*********************************************************************/
case: proc options(main);
Dcl dog Char(20) Var;
dog = "Benjamin";
Dog = "Samba";
DOG = "Bernie";
Put Edit(dog,Dog,DOG)(Skip,3(a,x(1)));
End;
Output
Bernie Bernie Berni
Plain English
Plain English is NOT case sensitive.
To run:
Start up.
Put "Benjamin" into a DOG string.
Put "Samba" into the Dog string.
Put "Bernie" into the dog string.
Write "There is just one dog named " then the DOG on the console.
Wait for the escape key.
Shut down.
- Output:
There is just one dog named Bernie
PowerShell
PowerShell is not case sensitive.
$dog = "Benjamin"
$Dog = "Samba"
$DOG = "Bernie"
"There is just one dog named {0}." -f $dOg
- Output:
There is just one dog named Bernie.
Prolog
In Prolog, the initial of a variable must be a uppercase letter. So the task can't be completed but we can write this code :
three_dogs :-
DoG = 'Benjamin',
Dog = 'Samba',
DOG = 'Bernie',
format('The three dogs are named ~w, ~w and ~w.~n', [DoG, Dog, DOG]).
The output is :
?- three_dogs. The three dogs are named Benjamin, Samba and Bernie. true.
PureBasic
dog$="Benjamin"
Dog$="Samba"
DOG$="Bernie"
Debug "There is just one dog named "+dog$
Python
Python names are case sensitive:
>>> dog = 'Benjamin'; Dog = 'Samba'; DOG = 'Bernie'
>>> print ('The three dogs are named ',dog,', ',Dog,', and ',DOG)
The three dogs are named Benjamin , Samba , and Bernie
>>>
Quackery
[ $ 'Benjamin' ] is dog ( --> $ )
[ $ 'Samba' ] is Dog ( --> $ )
[ $ 'Bernie' ] is DOG ( --> $ )
say 'There are three dogs named '
dog echo$ say ', '
Dog echo$ say ', and '
DOG echo$ say '.' cr
- Output:
There are three dogs named Benjamin, Samba, and Bernie.
R
dog <- 'Benjamin'
Dog <- 'Samba'
DOG <- 'Bernie'
# Having fun with cats and dogs
cat('The three dogs are named ')
cat(dog)
cat(', ')
cat(Dog)
cat(' and ')
cat(DOG)
cat('.\n')
# In one line it would be:
# cat('The three dogs are named ', dog, ', ', Dog, ' and ', DOG, '.\n', sep = '')
Output:
The three dogs are named Benjamin, Samba and Bernie.
Racket
The default setting for the Racket reader is to be case sensitive:
#lang racket
(define dog "Benjamin")
(define Dog "Samba")
(define DOG "Bernie")
(if (equal? dog DOG)
(displayln (~a "There is one dog named " DOG "."))
(displayln (~a "The three dogs are named " dog ", " Dog ", and, " DOG ".")))
Output:
The three dogs are named Benjamin, Samba, and, Bernie.
If you need case insensitive identifiers, then use #ci to turn on case insensitivity:
#lang racket
#ci(module dogs racket
(define dog "Benjamin")
(set! Dog "Samba")
(set! DOG "Bernie")
(if (equal? dog DOG)
(displayln (~a "There is one dog named " DOG "."))
(displayln (~a "The three dogs are named " dog ", " Dog ", and, " DOG "."))))
(require 'dogs)
Output:
There is one dog named Bernie.
Raku
(formerly Perl 6)
my $dog = 'Benjamin';
my $Dog = 'Samba';
my $DOG = 'Bernie';
say "The three dogs are named $dog, $Dog, and $DOG."
The only place that Raku pays any attention to the case of identifiers is that, for certain error messages, it will guess that an identifier starting lowercase is probably a function name, while one starting uppercase is probably a type or constant name. But this case distinction is merely a convention in Raku, not mandatory:
constant dog = 'Benjamin';
sub Dog() { 'Samba' }
my &DOG = { 'Bernie' }
say "The three dogs are named {dog}, {Dog}, and {DOG}."
Retro
Retro is case sensitive.
: dog ( -$ ) "Benjamin" ;
: Dog ( -$ ) "Samba" ;
: DOG ( -$ ) "Bernie" ;
DOG Dog dog "The three dogs are named %s, %s, and %s.\n" puts
REXX
simple variables
The REXX language is case insensitive (with respect to simple variables).
/*REXX program demonstrate case insensitivity for simple REXX variable names. */
/* ┌──◄── all 3 left─hand side REXX variables are identical (as far as assignments). */
/* │ */
/* ↓ */
dog= 'Benjamin' /*assign a lowercase variable (dog)*/
Dog= 'Samba' /* " " capitalized " Dog */
DOG= 'Bernie' /* " an uppercase " DOG */
say center('using simple variables', 35, "─") /*title.*/
say
if dog\==Dog | DOG\==dog then say 'The three dogs are named:' dog"," Dog 'and' DOG"."
else say 'There is just one dog named:' dog"."
/*stick a fork in it, we're all done. */
output
──────using simple variables─────── There is just one dog named: Bernie.
compound variables
However, the REXX language is case sensitive (with respect to compound variables, or indices).
/*REXX program demonstrate case sensitive REXX index names (for compound variables). */
/* ┌──◄── all 3 indices (for an array variable) are unique (as far as array index). */
/* │ */
/* ↓ */
x= 'dog'; dogname.x= "Gunner" /*assign an array index, lowercase dog*/
x= 'Dog'; dogname.x= "Thor" /* " " " " capitalized Dog*/
x= 'DOG'; dogname.x= "Jax" /* " " " " uppercase DOG*/
x= 'doG'; dogname.x= "Rex" /* " " " " mixed doG*/
say center('using compound variables', 35, "═") /*title.*/
say
_= 'dog'; say "dogname.dog=" dogname._ /*display an array index, lowercase dog*/
_= 'Dog'; say "dogname.Dog=" dogname._ /* " " " " capitalized Dog*/
_= 'DOG'; say "dogname.DOG=" dogname._ /* " " " " uppercase DOG*/
_= 'doG'; say "dogname.doG=" dogname._ /* " " " " mixed doG*/
/*stick a fork in it, we're all done. */
output
═════using compound variables══════ dogname.dog= Gunner dogname.Dog= Thor dogname.DOG= Jax dogname.doG= Rex
Ring
dog = "Benjamin"
doG = "Smokey"
Dog = "Samba"
DOG = "Bernie"
see "The 4 dogs are : " + dog + ", " + doG + ", " + Dog + " and " + DOG + "."
Ruby
Ruby gives a special meaning to the first letter of a name. A lowercase letter starts a local variable. An uppercase letter starts a constant. So dog is a local variable, but Dog and DOG are constants. To adapt this task to Ruby, I added dOg and doG so that I have more than one local variable.
module FiveDogs
dog = "Benjamin"
dOg = "Dogley"
doG = "Fido"
Dog = "Samba" # this constant is FiveDogs::Dog
DOG = "Bernie" # this constant is FiveDogs::DOG
names = [dog, dOg, doG, Dog, DOG]
names.uniq!
puts "There are %d dogs named %s." % [names.length, names.join(", ")]
puts
puts "The local variables are %s." % local_variables.join(", ")
puts "The constants are %s." % constants.join(", ")
end
Output:
There are 5 dogs named Benjamin, Dogley, Fido, Samba, Bernie. The local variables are dog, dOg, doG, names. The constants are Dog, DOG.
Run BASIC
dog$ = "Benjamin"
doG$ = "Smokey"
Dog$ = "Samba"
DOG$ = "Bernie"
print "The 4 dogs are "; dog$; ", "; doG$; ", "; Dog$; " and "; DOG$; "."
Rust
Rust style dictates that identifiers should be written in snake case, e.g. big_dog, small_dog; whereas types (structs and enums) should be written in camel case, e.g. BigDog, SmallDog. Failing to comply with this standard does not cause a compiler error, but it will trigger a compiler warning, and the culture is very strongly towards compliance with this standard.
fn main() {
let dog = "Benjamin";
let Dog = "Samba";
let DOG = "Bernie";
println!("The three dogs are named {}, {} and {}.", dog, Dog, DOG);
}
This triggers two warnings at compilation:
<anon>:3:9: 3:12 warning: variable `Dog` should have a snake case name such as `dog`, #[warn(non_snake_case)] on by default
<anon>:3 let Dog = "Samba";
^~~
<anon>:4:9: 4:12 warning: variable `DOG` should have a snake case name such as `dog`, #[warn(non_snake_case)] on by default
<anon>:4 let DOG = "Bernie";
^~~
The resulting program will compile and run just fine, producing the output:
The three dogs are named Benjamin, Samba and Bernie.
Sather
Though by convention Sather uses all uppercase letters for class names, a variable can be all uppercase.
class MAIN is
main is
dog ::= "Benjamin";
Dog ::= "Samba";
DOG ::= "Bernie";
#OUT + #FMT("The three dogs are %s, %s and %s\n",
dog, Dog, DOG);
end;
end;
Outputs:
The three dogs are Benjamin, Samba and Bernie
Scala
val dog = "Benjamin"
val Dog = "Samba"
val DOG = "Bernie"
println("There are three dogs named " + dog + ", " + Dog + ", and " + DOG + ".")
Output:
There are three dogs named Benjamin, Samba, and Bernie.
Scheme
Output may differ depending on implementation.
(define dog "Benjamin")
(define Dog "Samba")
(define DOG "Bernie")
(if (eq? dog DOG)
(begin (display "There is one dog named ")
(display DOG)
(display ".")
(newline))
(begin (display "The three dogs are named ")
(display dog) (display ", ")
(display Dog) (display " and ")
(display DOG)
(display ".")
(newline)))
Seed7
$ include "seed7_05.s7i";
const string: dog is "Benjamin";
const string: Dog is "Samba";
const string: DOG is "Bernie";
const proc: main is func
begin
writeln("The three dogs are named " <& dog <& ", " <& Dog <& " and " <& DOG <& ".");
end func;
SenseTalk
As a People Oriented Programming language, SenseTalk's variable names are case-insensitive.
set dog to "Benjamin"
set Dog to "Samba"
set DOG to "Bernie"
put !"There is just one dog named [[dog]]."
- Output:
There is just one dog named Bernie.
SETL
dog := 'Benjamin';
Dog := 'Samba';
DOG := 'Bernie';
print( 'There is just one dog named', dOg );
- Output:
There is just one dog named Bernie
Sidef
var dog = 'Benjamin';
var Dog = 'Samba';
var DOG = 'Bernie';
say "The three dogs are named #{dog}, #{Dog}, and #{DOG}.";
- Output:
The three dogs are named Benjamin, Samba, and Bernie.
Simula
Simula identifiers are case-insensitive, and the compiler will indignantly reject a program that tries to declare multiple variables with names differing only in case. (Same with key words: Case of a character in Simula code generally only matters in a simple string or a character constant.)
begin
text dog;
dog :- blanks( 8 );
dog := "Benjamin";
Dog := "Samba";
DOG := "Bernie";
outtext( "There is just one dog, named " );
outtext( dog );
outimage
end
- Output:
There is just one dog, named Bernie
Smalltalk
Smalltalk's symbols are case sensitive.
|dog Dog DOG|
dog := 'Benjamin'.
Dog := 'Samba'.
DOG := 'Bernie'.
( 'The three dogs are named %1, %2 and %3' %
{ dog . Dog . DOG } ) displayNl.
Outputs:
The three dogs are named Benjamin, Samba and Bernie
SNOBOL4
DOG = 'Benjamin'
Dog = 'Samba'
dog = 'Bernie'
OUTPUT = 'The three dogs are named ' DOG ', ' Dog ', and ' dog
END
- Output:
The three dogs are named Benjamin, Samba, and Bernie
Standard ML
Standard ML is case sensitive.
let
val dog = "Benjamin"
val Dog = "Samba"
val DOG = "Bernie"
in
print("The three dogs are named " ^ dog ^ ", " ^ Dog ^ ", and " ^ DOG ^ ".\n")
end;
- Output:
The three dogs are named Benjamin, Samba, and Bernie.
Stata
Stata is case-sensitive.
. local dog Benjamin
. local Dog Samba
. local DOG Bernie
. display "The three dogs are named $_dog, $_Dog, and $_DOG."
The three dogs are named Benjamin, Samba, and Bernie.
Swift
let dog = "Benjamin"
let Dog = "Samba"
let DOG = "Bernie"
println("The three dogs are named \(dog), \(Dog), and \(DOG).")
Tcl
Tcl variable names are case sensitive:
set dog "Benjamin"
set Dog "Samba"
set DOG "Bernie"
puts "The three dogs are named $dog, $Dog and $DOG"
Which prints...
The three dogs are named Benjamin, Samba and Bernie
True BASIC
True Basic is case-insensitive
LET dog$ = "Benjamin"
LET Dog$ = "Samba"
LET DOG$ = "Bernie"
PRINT "There is just one dog, named "; dog$
END
UNIX Shell
dog="Benjamin"
Dog="Samba"
DOG="Bernie"
echo "The three dogs are named $dog, $Dog and $DOG."
The three dogs are named Benjamin, Samba and Bernie.
Ursa
Ursa names are case sensitive:
> decl string dog Dog DOG
> set dog "Benjamin"
> set Dog "Samba"
> set DOG "Bernie"
> out "The three dogs are named " dog ", " Dog ", and " DOG endl console
The three dogs are named Benjamin, Samba, and Bernie
>
VBA
VBA is case sensitive case insensitive. The variable names 'dog', 'Dog' and 'DOG' can not co-exist.
Public Sub case_sensitivity()
'VBA does not allow variables that only differ in case
'The VBA IDE vbe will rename variable 'dog' to 'DOG'
'when trying to define a second variable 'DOG'
Dim DOG As String
DOG = "Benjamin"
DOG = "Samba"
DOG = "Bernie"
Debug.Print "There is just one dog named " & DOG
End Sub
- Output:
There is just one dog named Bernie
Wren
Identifiers in Wren are case sensitive.
var dog = "Benjamin"
var Dog = "Samba"
var DOG = "Bernie"
System.print("The three dogs are named %(dog), %(Dog) and %(DOG).")
- Output:
The three dogs are named Benjamin, Samba and Bernie.
XBS
In XBS variable names are case-sensitive.
set dog="Benjamin";
set DOG="Samba";
set Dog="Bernie";
log(`The three dogs are named {dog}, {DOG} and {Dog}.`);
- Output:
The three dogs are named Benjamin, Samba and Bernie.
XLISP
XLISP is entirely case-insensitive. The user can decide whether to have the system print symbols, etc., in capitals or in lower case, by assigning to the variable *PRINT-CASE*.
(SETQ DOG 'BENJAMIN)
(SETQ Dog 'SAMBA)
(SETQ dog 'BERNIE)
(DISPLAY `(THERE IS JUST ONE DOG NAMED ,DOG))
There is, in any event, only one dog.
(THERE IS JUST ONE DOG NAMED BERNIE)
XPL0
XPL0 is normally case-insensitive, so there is really just one dog named Bernie. However, it has a command-line switch (/c) that turns case sensitivity on. All names must start with a capital letter (or an underline, so they can't clash with command words such as 'for'). Thus "dog" cannot be used as a name, but Dog, DOG and DoG (and For) can. The intent of the command-line switch (/c) is to detect inconsistent capitalizing of names such as Ascii and ASCII or CpuReg and CPUReg.
Yabasic
Yabasic names are case sensitive:
dog$ = "Benjamin"
Dog$ = "Samba"
DOG$ = "Bernie"
print "The three dogs are named ", dog$, ", ", Dog$, " and ", DOG$
end
zkl
var dog = "Benjamin", Dog = "Samba", DOG = "Bernie";
- Output:
vars L(L("DOG","Bernie"),L("Dog","Samba"),L("dog","Benjamin"))
ZX Spectrum Basic
10 LET D$="Benjamin"
20 PRINT "There is just one dog named ";d$
- Programming Tasks
- Case Sensitivity
- 11l
- Action!
- Ada
- Agena
- Aime
- ALGOL 68
- ALGOL W
- APL
- Arturo
- AutoHotkey
- AWK
- BASIC
- BASIC256
- Batch File
- BBC BASIC
- Bc
- Bracmat
- Brlcad
- C
- C sharp
- C++
- Clojure
- COBOL
- CoffeeScript
- Common Lisp
- Crystal
- D
- Dc
- Delphi
- DWScript
- Déjà Vu
- EchoLisp
- Elena
- Elixir
- Erlang
- Euphoria
- F Sharp
- Factor
- Forth
- Fortran
- FreeBASIC
- Frink
- Gambas
- GAP
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Julia
- K
- Kotlin
- Lasso
- Liberty BASIC
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Maxima
- Min
- MiniScript
- Modula-2
- Nanoquery
- Nemerle
- NESL
- NetRexx
- Nim
- Oberon-2
- Objeck
- OCaml
- Oforth
- Ol
- PARI/GP
- Pascal
- Perl
- Phix
- Phix/basics
- PicoLisp
- PL/I
- Plain English
- PowerShell
- Prolog
- PureBasic
- Python
- Quackery
- R
- Racket
- Raku
- Retro
- REXX
- Ring
- Ruby
- Run BASIC
- Rust
- Sather
- Scala
- Scheme
- Seed7
- SenseTalk
- SETL
- Sidef
- Simula
- Smalltalk
- SNOBOL4
- Standard ML
- Stata
- Swift
- Tcl
- True BASIC
- UNIX Shell
- Ursa
- VBA
- Wren
- XBS
- XLISP
- XPL0
- Yabasic
- Zkl
- ZX Spectrum Basic
- 360 Assembly/Omit
- 6502 Assembly/Omit
- 8051 Assembly/Omit
- 8080 Assembly/Omit
- 8086 Assembly/Omit
- 68000 Assembly/Omit
- AArch64 Assembly/Omit
- ARM Assembly/Omit
- MIPS Assembly/Omit
- Sed/Omit
- X86 Assembly/Omit
- Z80 Assembly/Omit