Periodic table: Difference between revisions

Since the 6502 can't index an array larger than 256 bytes, we'll store all the "low bytes" in one table and all the "high bytes" in another. Both tables share the same index, so this lets us store up to 255 possible elements while taking the same amount of memory as a single table of 16-bit values. Right now, we can do this either way, but since we're close to 128 elements, may as well future-proof the code, right?

 

LDA PeriodicTable_Column,x

STA $20 ;store column number in memory (I chose $20 arbitrarily, you can store it anywhere)

db $ff,$01,$18,$01,$02,$13,$14,$15,$16,$17,$18,... ;I don't need to write them all out, the concept is self-explanatory enough.

PeriodicTable_Row:

 

=={{header|68000 Assembly}}==

The table consists of 118 16-bit values. The high byte is the row number, the low byte is the column number. Both are stored as binary-coded decimal (i.e. hex values that look like base 10 numbers.)

 

;input: D0.W = the atomic number of interest.

LEA PeriodicTable,A0

DC.W $0217 ;FLUORINE

DC.W $0218 ;NEON

 

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

# given its atomic number #

INT max atomic number = 118; # highest known element #

FI

OD

{{out}}

<pre>

==={{header|Applesoft BASIC}}===

This program borrows from the [[#Python|Python]] solution but only PRINTs the results of the tests shown in the task. Each row and column from the tests are PLOTted in a COLORful table.

1 forr=2to7:forc=13to18:GOSUB7:NEXTC,R:COLOR=14:R=8:FORC=4TO18:GOSUB7:NEXTC:COLOR=12:R=9:FORC=4TO18:GOSUB7:NEXTC:R=9:FORC=4TO18:GOSUB7:NEXTC:Z=2:R=7:C=3:GOSUB7:COLOR=14:R=6:C=3:GOSUB7:COLOR=15

2 S=14:W=18:FORI=1TO7:READN(I),I(I):NEXT:DATA2,0,10,0,18,0,36,0,54,0,86,57,118,89,1,1,1,2,1,18,29,4,11,42,5,6,57,8,4,58,8,5,72,6,4,89,9,4,59,8,6,71,8,18,90,9,5,103,9,18

5 E=N-P:K=A-P:IFI(R)AND(I(R)<=AANDA<=I(R)+S)THENR=R+2:C=K+1:RETURN

6 E=W-E:L=1+(N>2):C=K+E*(K>L):RETURN

 

=== {{header|ASIC}} ===

{{trans|Nascom BASIC}}

REM Periodic table

DIM A(7)

PRINT C

RETURN

{{out}}

<pre>

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

{{trans|FreeBASIC}}

dim A = { 1, 2, 5, 13, 57, 72, 89, 104}

dim B = {-1, 15, 25, 35, 72, 21, 58, 7}

for I = 0 to Element[?]-1

call MostarPos(Element[I])

{{out}}

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

==={{header|FreeBASIC}}===

{{trans|XPL0}}

Dim As Integer M, I, R, C

Dim As Integer A(0 To 7) = { 1, 2, 5, 13, 57, 72, 89, 104} 'magic numbers

For I As Integer = 0 To Ubound(Element)

MostarPos(Element(I))

{{out}}

<pre>Atomic number 1 -> 1, 1

==={{header|FutureBasic}}===

Old fashioned way:

include "NSLog.incl"

 

 

HandleEvents

{{out}}

<pre>

 

Modern way. (Too bad you can no longer upload images to Rosetta Code.)

_window = 1

 

 

HandleEvents

{{out}}

<pre>

 

==={{header|Gambas}}===

Dim M, I, R, C As Integer

Dim A As Integer[] = [1, 2, 5, 13, 57, 72, 89, 104] 'magic numbers

Next

 

{{out}}

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

{{trans|Nascom BASIC}}

{{works with|Commodore BASIC|3.5}}

10 REM Periodic table

20 GOSUB 200

1030 REM Example elements (atomic numbers).

1040 DATA 1, 2, 29, 42, 57, 58, 72, 89, 90, 103

 

=== {{header|Nascom BASIC}} ===

{{works with|Nascom ROM BASIC|4.7}}

10 REM Periodic table

20 GOSUB 200

1030 REM ** Example elements (atomic numbers).

1040 DATA 1,2,29,42,57,58,72,89,90,103

{{out}}

<pre>

{{works with|QuickBasic|4.5}}

{{trans|FreeBASIC}}

DIM a(7)

RESTORE a:

DATA 1, 2, 5, 13, 57, 72, 89, 104

b:

{{out}}

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

{{works with|Liberty BASIC}}

{{trans|FreeBASIC}}

Element(0) = 1

Element(1) = 2

C = (M mod 18) +1

print "Atomic number "; using("###", N); " -> "; R; ", "; C

{{out}}

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

==={{header|True BASIC}}===

{{trans|FreeBASIC}}

DIM a(0 TO 7)

LET a(0) = 1

CALL MostarPos (element(e))

NEXT e

{{out}}

<pre>Similar to FreeBASIC entry.</pre>

{{works with|Windows XBasic}}

{{trans|FreeBASIC}}

 

DECLARE FUNCTION Entry ()

 

END FUNCTION

{{out}}

<pre>Similar to FreeBASIC entry.</pre>

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

{{trans|FreeBASIC}}

// by Jjuanhdez, 06/2022

 

C = mod(M, 18) +1

print "Atomic number ", N using("###"), " -> ", R, ", ", C

{{out}}

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

=={{header|Go}}==

{{trans|Wren}}

 

import (

fmt.Printf("Atomic number %3d -> %d, %-2d\n", n, row, col)

}

 

{{out}}

Basically, here, we want a lookup table. For example:

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

1 H He

}}

 

 

In other words, start with a hand crafted representation of the periodic table. Elements here are tokens with 1 or 2 letters. Locate the position of each token in the table. Get an initial row and column number from the character positions in the table. Translate character column to periodic table column by enumerating the unique (sorted) list of column numbers and using the index in that list. Character row was already periodic table row. Most elements here were already in atomic number order, and we can fix the exceptions by temporarily prefixing each row,col value and sorting. (Here, we use 0 for the first 56 elements, 3 for the next 17 elements (after Lantanoidi, before Aktinoidi), 12 for the next 15 (after Aktinoidi), 2 for the next 15 (the Lantanoidi) and 11 for the final 15 elements (the Aktinoidi).)

Thus:

 

1 1

1 18

8 5

6 4

 

 

=={{header|Julia}}==

{{trans|Wren}}

 

function periodic_table(n)

println("Atomic number ", lpad(n, 3), " -> ($(rc[1]), $(rc[2]))")

end

<pre>

Atomic number 1 -> (1, 1)

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

Mathematica and the Wolfram language include the period and group in the function ElementData but has slightly different definitions for the lantanides and aktinoides.

FindPeriodGroup[n_Integer] := Which[57 <= n <= 70,

{8, n - 53}

]

Row[{"Element ", #, " -> ", FindPeriodGroup[#]}] & /@ {1, 2, 29, 42, 57, 58, 59, 71, 72, 89, 90, 103, 113} // Column

{{out}}

<pre>Element 1 -> {1,1}

=={{header|Perl}}==

{{trans|Raku}}

use warnings; no warnings 'uninitialized';

use feature 'say';

for my $n (<1 2 29 42 57 58 72 89 90 103 118>) {

printf "%3d: %2d, %2d\n", $n, map { $_+1 } divmod $n-1 + sum(head $span[$n-1], @offset), $b;

{{out}}

<pre> 1: 1, 1

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">match_wp</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</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;">"%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">pt</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"|"</span><span style="color: #0000FF;">}}),</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)})</span>

{{out}}

With match_wp set to true:

</pre>

===alternate===

<span style="color: #008080;">constant</span> <span style="color: #000000;">ptxt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""

__________________________________________________________________________

<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;">"Element %d %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pt</span><span style="color: #0000FF;">[</span><span style="color: #000000;">e</span><span style="color: #0000FF;">]})</span>

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

{{out}}

<pre>

A solution trying hard not to encode too much data about the table.

 

def perta(atomic) -> (int, int):

 

print('TEST:{:3d} -> '.format(input) + str(found) + (f' ; ERROR: expected {out}' if found != out else ''))

 

 

=={{header|Raku}}==

my @offset = 16, 10, 10, (2×$b)+1, (-2×$b)-15, (2×$b)+1, (-2×$b)-15;

my @span = flat ^8 Zxx <1 3 8 44 15 17 15 15>;

for <1 2 29 42 57 58 72 89 90 103> -> $n {

printf "%3d: %2d, %2d\n", $n, map {$_+1}, ($n-1 + [+] @offset.head(@span[$n-1])).polymod($b).reverse;

{{out}}

<pre> 1: 1, 1

{{libheader|Wren-fmt}}

There is a discrepancy between how the periodic table is arranged in the Wikipedia article and how it is arranged in the task description. I've used the latter in the following script.

 

var limits = [3..10, 11..18, 19..36, 37..54, 55..86, 87..118]

var rc = periodicTable.call(n)

Fmt.print("Atomic number $3d -> $d, $-2d", n, rc[0], rc[1])

 

{{out}}

 

=={{header|XPL0}}==

int N, M, A, B, I, R, C;

[A:= [ 1, 2, 5, 13, 57, 72, 89, 104]; \magic numbers

[Element:= [1, 2, 29, 42, 57, 58, 72, 89, 90, 103];

for I:= 0 to 10-1 do ShowPosn(Element(I));

 

{{out}}