Vintage Computing Christmas Challenge 2022 (VC³ 2022)

Discussions
62

I’m here :slight_smile: The question on a single key measurement is a little difficult. I don’t have any loose keyboards or individual keys at the moment.

I do have a digital micrometer, but the battery is dead :smiley: Anyhow, measuring one of the corner keys, the best I can figure is 18mm. There are a few odd-sized keys like Execute, CMD, shift.

But for the “normal keys”, I can’t say if these are exactly square - they seem to be. I tried to measure as close to the base as I could - there could be one more mm all around past the keyboard enclosure itself, making the base closer to 20mm square.

image
image739×815 65.2 KB

I’ll ask at https://deskthority.net/ if any of those folks know.

2 Likes
63

Why, do you need one for building a time machine?

Reference: steins;gate.

1 Like
64

Thank you very much! This is exactly what I need =)

65

I looked at it recently. I was inspired and decided to make a 3D model of a computer and a divergence meter. I want to convey all the dimensions and elements as accurately as possible.

66

Wow, it will look great next to the nixie tubes! Best of luck.

1 Like
67

Finally, I finished and arranged the work as it should be

Many thanks to everyone who helped

https://www.artstation.com/artwork/g0yk0Q

2 Likes
68

It looks great!

I saw only a few days ago apparently there were these toy clock IBN 5100 models:

Hey, I know someone who used to work at SERN… I mean CERN.

1 Like
69

The thread that keeps on giving :wink:

So yes, it’s well past the end date and this ‘entry’ is in a very new language, so highly probably off-topic, but it’s one that amongst other things was initially intended to be something somewhat minimalistic that might have run on systems of “the period” - I’ll leave that for you to decide… However here is my 2nd entry in my own little slightly esoteric language (called Apricot):

~ 2022 Vintage Computing Challenge
~	This version in APRICOT by Gordon Henderson.
~	https://projects.drogon.net/apricot/


~    *       *		5, 1, 7, 1
~    **     **		5, 2, 5, 2
~    ***   ***		5, 3, 3, 3
~    **** ****		5, 4, 1, 4
~*****************	0, 17
~ ***************	1, 15
~  *************	2, 13
~   ***********		3, 11
~    *********		4,  9
~   ***********
~  *************
~ ***************
~*****************
~    **** ****
~    ***   ***
~    **     **
~    *       *


"2022"#

~ P is count of stars, Q is count of spaces

1=P  7=Q [ ;A P;X Q;S P;X # P+1=P Q-2=Q +1 ]
0=Q 17=P [ Q;S P;X        # P-2=P Q+1=Q -5 ]
3=Q 11=P [ Q;S P;X        # P+2=P Q-1=Q +1 ]
4=P  1=Q [ ;A P;X Q;S P;X # P-1=P Q+2=Q -9 ]
_

(S [ " " -1 ])
(X [ "*" -1 ])
(A 4;S)

A-Ha. The editor here has thwarted me - as it uses the back-tick to represent block-quotes but my code here uses back-ticks to represent comments, so anyone actually daft enough to try to run this will need to change the twiddles back into back-ticks …

This is a run:

APRICOT: A PRogrammable Interactive Calculate O Tron.
  v1.3. Copyright (c) 2023 by Gordon Henderson.
  Up to 8000 numbers of free store available.

Ready
          0: :e
Edit Mode. Type ? For Help

> l
Load program
  Filename: 2022.cot
> c
"2022"#1=P7=Q[;AP;XQ;SP;X#P+1=PQ-2=Q+1]0=Q17=P[Q;SP;X#P-2=PQ+1=Q-5]3=Q11=P[Q;SP;X#P+2=PQ-1=Q+1]4=P1=Q[;AP;XQ;SP;X#P-1=PQ+2=Q-9]_(S[" "-1])(X["*"-1])(A4;S)
> r
2022
    *       *
    **     **
    ***   ***
    **** ****
*****************
 ***************
  *************
   ***********
    *********
   ***********
  *************
 ***************
*****************
    **** ****
    ***   ***
    **     **
    *       *
+++ Program END
>

The internal ‘compiled’ code is about 73 bytes long. It could be optimised but lifes short enough.

And if you really are daft enough to want to know more then

https://projects.drogon.net/apricot/

is where it’s at…

Cheers,

-Gordon

5 Likes
70

Well, didn’t resist and did my 5 minutes attempt on this with C#, console app:

for (int i = 0; i < 13; i++)
{
    PrintStars(4, i, i + 1);
    PrintStars(4, 16 - i, i + 1);
    PrintStars(12 - i, i, i + 1);
    PrintStars(12 - i, 16 - i, i + 1);
}

Console.ReadLine();

static void PrintStars(int x, int y, int count)
{
    Console.SetCursorPosition(x, y);
    Console.Write(new string('*', count));
}

… which produces this

image

This ‘vanilla’ implementation is radically different from the majority of way more clever methods around here (respect for that). For one thing, it’s not optimized, it basically draws four right angle triangles made of stars on top of each other. For a low-end machine, that would be a waste of precious resources.

However, this implementation was fast to complete, quite readable and lets the user optimize later only if needed. Since the requirements of the challenge make no mention of performance or other limitations, I’ll humbly submit it as it is.

3 Likes