Practice Code Typing – SkillsTyping

Choose your language:

ℹ️ Select 'Choose Exercise', or randomize 'Next Random Exercise' in selected language.

Choose Exercise:

Ready

Exercise Algorithm Area

Correct typos to continue.

1#define PI 3.1415926535
2
3/*
4* Macro to transform workpiece coordinates based on a rotation angle.
5* This is useful when the workpiece is fixtured at an angle relative to the machine axes.
6*/
7Sub TransformWorkpieceCoordinates(angleDegrees As Float, inputX As Float, inputY As Float, inputZ As Float, ByRef outputX As Float, ByRef outputY As Float, ByRef outputZ As Float)
8Dim angleRadians As Float
9Dim cosAngle As Float
10Dim sinAngle As Float
11
12' --- Input Validation ---
13' Angle validation: Normalize angle to be within 0-360 degrees.
14angleDegrees = Modulo(angleDegrees, 360.0)
15If angleDegrees < 0 Then
16angleDegrees = angleDegrees + 360.0
17End If
18
19' If angle is 0 or 360, no transformation is needed.
20If angleDegrees = 0.0 Then
21outputX = inputX
22outputY = inputY
23outputZ = inputZ
24MsgBox "Rotation angle is 0 degrees. No transformation applied."
25Return
26End If
27
28' Convert angle from degrees to radians for trigonometric functions.
29angleRadians = angleDegrees * (PI / 180.0)
30
31' Calculate cosine and sine of the angle.
32cosAngle = Cos(angleRadians)
33sinAngle = Sin(angleRadians)
34
35' --- Apply 2D Rotation Transformation (around Z-axis) ---
36' The standard 2D rotation matrix is:
37' | cos(theta)  -sin(theta) |
38' | sin(theta)   cos(theta) |
39' Applied to [x, y]^T
40
41outputX = inputX * cosAngle - inputY * sinAngle
42outputY = inputX * sinAngle + inputY * cosAngle
43
44' Z-axis is typically unaffected by rotation around Z.
45outputZ = inputZ
46
47MsgBox "Coordinates transformed. Original (X,Y,Z): (" + Format(inputX) + "," + Format(inputY) + "," + Format(inputZ) + ")"
48MsgBox "Transformed (X,Y,Z): (" + Format(outputX) + "," + Format(outputY) + "," + Format(outputZ) + ")"
49
50End Sub
51
52/*
53* Helper function to calculate the modulo of two floats.
54*/
55Function Modulo(numerator As Float, denominator As Float) As Float
56' Basic modulo implementation for floats.
57Modulo = numerator - Floor(numerator / denominator) * denominator
58End Function
59
60/*
61* Helper function to get the floor of a float.
62*/
63Function Floor(value As Float) As Float
64' Placeholder for floor function.
65Floor = Int(value) ' Assuming Int truncates towards zero, adjust if needed.
66End Function
67
68/*
69* Helper function to display a message box.
70*/
71Sub MsgBox(message As String)
72Print "[MESSAGE] " + message
73End Sub
74
75/*
76* Helper function to format a float for display.
77*/
78Function Format(value As Float) As String
79Format = "" + value
80End Function
81
82/*
83* Main program to demonstrate coordinate transformation.
84*/
85Sub Main()
86Dim rotationAngle As Float
87Dim originalX As Float, originalY As Float, originalZ As Float
88Dim transformedX As Float, transformedY As Float, transformedZ As Float
89
90Print "--- Test Case 1: Simple Rotation ---"
91rotationAngle = 90.0
92originalX = 10.0
93originalY = 0.0
94originalZ = 5.0
95TransformWorkpieceCoordinates(rotationAngle, originalX, originalY, originalZ, transformedX, transformedY, transformedZ)
96' Expected: X=0, Y=10, Z=5
97
98Print "\n--- Test Case 2: Rotation by 45 degrees ---"
99rotationAngle = 45.0
100originalX = 10.0
101originalY = 10.0
102originalZ = 2.0
103TransformWorkpieceCoordinates(rotationAngle, originalX, originalY, originalZ, transformedX, transformedY, transformedZ)
104' Expected: X=0, Y=14.14, Z=2
105
106Print "\n--- Test Case 3: Zero Rotation ---"
107rotationAngle = 0.0
108originalX = 20.0
109originalY = 30.0
110originalZ = 10.0
111TransformWorkpieceCoordinates(rotationAngle, originalX, originalY, originalZ, transformedX, transformedY, transformedZ)
112' Expected: X=20, Y=30, Z=10
113
114Print "\n--- Test Case 4: Rotation by 360 degrees ---"
115rotationAngle = 360.0
116originalX = 15.0
117originalY = 25.0
118originalZ = 8.0
119TransformWorkpieceCoordinates(rotationAngle, originalX, originalY, originalZ, transformedX, transformedY, transformedZ)
120' Expected: X=15, Y=25, Z=8
121
122Print "\n--- Test Case 5: Negative Angle ---"
123rotationAngle = -90.0
124originalX = 10.0
125originalY = 0.0
126originalZ = 5.0
127TransformWorkpieceCoordinates(rotationAngle, originalX, originalY, originalZ, transformedX, transformedY, transformedZ)
128' Expected: X=0, Y=-10, Z=5
129
130Print "\n--- Test Case 6: Angle greater than 360 ---"
131rotationAngle = 450.0 // Equivalent to 90 degrees
132originalX = 10.0
133originalY = 0.0
134originalZ = 5.0
135TransformWorkpieceCoordinates(rotationAngle, originalX, originalY, originalZ, transformedX, transformedY, transformedZ)
136' Expected: X=0, Y=10, Z=5
137
138End Sub

Algorithm description viewbox

Coordinate Transformation for Rotated Workpiece

Algorithm description:

This macro applies a 2D rotation transformation to workpiece coordinates, which is essential when a part is fixtured at an angle on the CNC machine. It takes the rotation angle (in degrees) and the original X, Y, and Z coordinates as input. The macro calculates the new X and Y coordinates based on standard rotation formulas, leaving Z unchanged. This allows the programmer to define coordinates in the part's natural orientation and have the machine automatically convert them to machine coordinates, simplifying complex setups.

Algorithm explanation:

The `TransformWorkpieceCoordinates` macro takes an angle in degrees and input X, Y, Z coordinates. It first validates and normalizes the angle to be within 0-360 degrees. If the angle is 0 or 360, it directly assigns input to output coordinates, avoiding unnecessary calculations. Otherwise, it converts the angle to radians and computes its cosine and sine. The core transformation uses the 2D rotation matrix: `outputX = inputX * cos(angle) - inputY * sin(angle)` and `outputY = inputX * sin(angle) + inputY * cos(angle)`. The Z-coordinate remains unchanged. Helper functions `Modulo` and `Floor` are used for angle normalization. The time complexity is O(1) as it involves a fixed number of arithmetic and trigonometric operations. Space complexity is O(1) for its local variables.

Pseudocode:

FUNCTION TransformWorkpieceCoordinates(angleDegrees, inputX, inputY, inputZ, OUT outputX, OUT outputY, OUT outputZ):
  angleDegrees = Modulo(angleDegrees, 360.0)
  IF angleDegrees < 0 THEN angleDegrees += 360.0

  IF angleDegrees == 0.0 THEN
    outputX = inputX
    outputY = inputY
    outputZ = inputZ
    RETURN
  END IF

  angleRadians = angleDegrees * (PI / 180.0)
  cosAngle = COS(angleRadians)
  sinAngle = SIN(angleRadians)

  outputX = inputX * cosAngle - inputY * sinAngle
  outputY = inputX * sinAngle + inputY * cosAngle
  outputZ = inputZ
END FUNCTION

Library

Playable exercises

Choose Exercise

Filter, sort, and preview algorithm before you choose one to play.

Total 4 published items

Pages 1 pages available

Language

Sort by Direction

Browse published coding scenarios with filters, sorting, and pagination.

Published

CNC Fanuc CNC (cnc-fanuc)

Coordinate Transformation for Rotated Workpiece

Difficulty: writing: 5; length: 10
Popularity: 0
Created: 2026-01-26 13:29 UTC
Published: 2026-01-26 13:40 UTC
Author: Admin

#coordinate transform #macros #rotation #geometry #fanuc #workpiece setup

goal: Apply a 2D rotation transformation to workpiece coordinates.

Canonical Algorithm Text

#define PI 3.1415926535 /* * Macro to transform workpiece coordinates based on a rotation angle. * This is useful when the workpiece is fixtured at an angle relative to the machine axes. */ Sub TransformWorkpieceCoordinates(angleDegrees As Float, inputX As Float, inputY As Float,...

Description Algorithm

This macro applies a 2D rotation transformation to workpiece coordinates, which is essential when a part is fixtured at an angle on the CNC machine. It takes the rotation angle (in degrees) and the original X, Y, and Z c...

Explanation

The `TransformWorkpieceCoordinates` macro takes an angle in degrees and input X, Y, Z coordinates. It first validates and normalizes the angle to be within 0-360 degrees. If the angle is 0 or 360, it directly assigns input to output coordinates, avoiding unnecessary calculations. Otherwise, it converts the angle to radians and computes its cosine and sine. The core transformation uses the 2D rotation matrix: `outputX = inputX * cos(angle) - inputY * sin(angle)` and `outputY = inputX * sin(angle) + inputY * cos(angle)`. The Z-coordinate remains unchanged. Helper functions `Modulo` and `Floor` are used for angle normalization. The time complexity is O(1) as it involves a fixed number of arithmetic and trigonometric operations. Space complexity is O(1) for its local variables.

Pseudocode

FUNCTION TransformWorkpieceCoordinates(angleDegrees, inputX, inputY, inputZ, OUT outputX, OUT outputY, OUT outputZ): angleDegrees = Modulo(angleDegrees, 360.0) IF angleDegrees < 0 THEN angleDegrees += 360.0 IF angleDegre...

Published

CNC Fanuc CNC (cnc-fanuc)

Tool Offset Compensation Manager with Wear Tracking

Difficulty: writing: 10; length: 10
Popularity: 0
Created: 2026-01-26 13:29 UTC
Published: 2026-01-26 13:40 UTC
Author: Admin

#tool management #offset compensation #wear tracking #fanuc #macros #maintenance #production

goal: Manage tool offsets and track tool wear for CNC machines. input: Tool number, measured offset values, usage hours. output: Updated tool offsets, wear status, and remaining tool life predictions.

Canonical Algorithm Text

#define MAX_TOOLS 100 #define MAX_WEAR_THRESHOLD 5.0 // mm #define TOOL_LIFE_HOURS 1000 // Structure to hold tool offset and wear data Type ToolData OffsetX As Float OffsetY As Float OffsetZ As Float CurrentWear As Float TotalHours As Float IsActive As Boolean End Type // Array t...

Description Algorithm

This macro system manages tool offset compensation and tracks tool wear for CNC machines. It allows for activation of tools, updating their offsets based on measured values, and recording their usage hours. The system al...

Explanation

The system uses a `ToolData` structure to store offset values (X, Y, Z), current wear, total usage hours, and an active status for each tool. `InitializeToolRegistry` sets up default values. `ActivateTool` enables a tool and sets its initial offsets. `UpdateOffsetCompensation` compares measured offsets to commanded ones, updates the tool's offsets, and accumulates wear based on the correction magnitude. It checks against `MAX_WEAR_THRESHOLD`. `RecordToolUsage` adds to `TotalHours` and calculates remaining life against `TOOL_LIFE_HOURS`, warning if life is exceeded. `GetToolOffsets` retrieves data for a specific tool, performing validation. Error handling is implemented for invalid tool numbers, inactive tools, negative wear accumulation, and exceeding thresholds. The time complexity for most operations is O(1) as they access a specific tool's data directly. Space complexity is O(M), where M is `MAX_TOOLS`, due to the `ToolRegistry` array.

Pseudocode

TYPE ToolData: OffsetX, OffsetY, OffsetZ, CurrentWear, TotalHours AS FLOAT IsActive AS BOOLEAN END TYPE DECLARE ToolRegistry[MAX_TOOLS] AS ToolData PROCEDURE InitializeToolRegistry(): FOR i FROM 1 TO MAX_TOOLS: ToolRegis...

Published

CNC Fanuc CNC (cnc-fanuc)

Parametric Macro for Hole Pattern Generation

Difficulty: writing: 6; length: 7
Popularity: 0
Created: 2026-01-26 13:29 UTC
Published: 2026-01-26 13:40 UTC
Author: Admin

#parametric #macros #geometry #pattern #cnc #fanuc #drilling

goal: Generate a circular pattern of holes. output: Prints the coordinates for each hole. In a real CNC, this would generate G-code.

Canonical Algorithm Text

#define MAX_HOLES 100 #define PI 3.1415926535 /* * Macro to generate a circular hole pattern using parametric programming. * Calculates hole positions based on center, radius, and number of holes. */ Sub GenerateCircularHolePattern(centerX As Float, centerY As Float, radius As Fl...

Description Algorithm

This macro generates a circular pattern of holes, commonly used in manufacturing for bolt circles or component mounting. It takes the center coordinates, radius, and the desired number of holes as parameters. The macro c...

Explanation

The `GenerateCircularHolePattern` macro utilizes basic trigonometry to determine the coordinates of each hole in a circular array. It first validates the input parameters, ensuring the radius is non-negative and the number of holes is positive. If invalid, it provides informative messages and exits. The core logic involves calculating the angular separation between holes (`angleStep`) and then iterating `numHoles` times. In each iteration, it uses `cos()` and `sin()` functions with the current angle and the given radius to find the relative offsets from the center. These offsets are added to the `centerX` and `centerY` to get the absolute hole coordinates. The loop invariant is that after `i` iterations, `i` holes have been correctly positioned. The time complexity is O(N), where N is the number of holes, as it performs a constant amount of work for each hole. Space complexity is O(1) as it only uses a few variables.

Pseudocode

FUNCTION GenerateCircularHolePattern(centerX, centerY, radius, numHoles): IF radius < 0 THEN DISPLAY "Error: Radius cannot be negative." RETURN END IF IF numHoles <= 0 THEN DISPLAY "Warning: Number of holes is zero or ne...

Published

CNC Fanuc CNC (cnc-fanuc)

Subprogram for Rectangular Pocket Machining

Difficulty: writing: 6; length: 10
Popularity: 0
Created: 2026-01-26 13:29 UTC
Published: 2026-01-26 13:40 UTC
Author: Admin

#subprogram #macros #pocketing #geometry #fanuc #modularization #cnc

goal: Machine a rectangular pocket with optional rounded corners. output: Generates G-code commands for pocket machining.

Canonical Algorithm Text

/* * Subprogram for machining a rectangular pocket with optional corner radius. * Parameters: * P_X: Center X coordinate of the pocket * P_Y: Center Y coordinate of the pocket * P_W: Width of the pocket * P_H: Height of the pocket * P_D: Depth of the pocket * P_R: Corner radius (...

Description Algorithm

This Fanuc macro subprogram is designed to machine a rectangular pocket with optional rounded corners. It accepts parameters defining the pocket's center, dimensions, depth, and corner radius. The subprogram calculates t...

Explanation

The `PocketRectangular` subprogram first validates its input parameters, checking for positive dimensions, negative depth, and non-negative radius. It then determines a `toolRadius` (hardcoded for this example, but ideally a parameter) and adjusts the requested `P_R` if it's too large for the pocket dimensions and tool, preventing collisions. The pocket's start and end coordinates are calculated, considering the corner radius. The machining sequence involves moving to a safe Z height, then positioning to the pocket's starting contour point. It plunges to the specified depth (`P_D`) using a controlled feed (simulated by `G01`). The contour is then traced with a series of `MoveTo` and `ArcTo` (simulated `G02`) commands, creating straight edges and rounded corners. Finally, it retracts to a safe Z height and returns control. The time complexity is O(1) as it performs a fixed sequence of operations regardless of pocket size. Space complexity is O(1) for its local variables.

Pseudocode

SUB PocketRectangular(P_X, P_Y, P_W, P_H, P_D, P_R): VALIDATE P_W > 0, P_H > 0, P_D < 0, P_R >= 0 IF validation fails THEN DISPLAY Error Message RETURN END IF toolRadius = GetToolRadius() // Placeholder IF P_R > (MIN(P_W...

Language (required)

Paste your code (required)

Max 20,000 characters. (Dangerous HTML/script fragments will be blocked)

Normalized preview:

I agree to Publish this, after admin approval (queued for review). (Not required) I confirm this submission is anonymous and does not contain personal data. I grant SkillsTyping a free, non-exclusive, worldwide, and irrevocable license to store, modify, adapt, and publish this content after review. I understand that publication is not guaranteed, that I retain no ownership or usage claims over published versions, and that no compensation will be provided. See Privacy Policy

Publish details

Shown only if you opt to submit for review. Required when consent is checked.

Title (required with consent)

Short description / summary (required with consent)

Algorithm explanation (required with consent)

Pseudocode (required with consent)