scratchpad - Recent changes [en]

Main Page

Admin — Fri, 11 Sep 2026 03:59:00 GMT

← Older revision		Revision as of 09:29, 11 September 2026
(One intermediate revision by the same user not shown)
Line 10:		Line 10:
	* [[Special:RecentChanges\|Recent changes]]		* [[Special:RecentChanges\|Recent changes]]
	* [[Special:AllPages\|Flat list of all pages]]		* [[Special:AllPages\|Flat list of all pages]]
	* [{{fullurl:Private:Journal/{{~~#time:Y\|+5 hours 30 minutes~~}}/{{~~#time:m\|+5 hours 30 minutes~~}}/{{~~#time:d\|+5 hours 30 minutes~~}}\|~~veaction~~=edit&preload=Template:DailyJournalPreload}}}} Create today's note]		* [{{fullurl:Private:Journal/{{LOCALYEAR}}/{{LOCALMONTH}}/{{LOCALDAY2}}\|action=edit&preload=Template:DailyJournalPreload}} Create today's note]

DSA/Chessboards and Queens

Admin — Thu, 03 Sep 2026 04:51:52 GMT

← Older revision		Revision as of 10:21, 3 September 2026
Line 268:		Line 268:
	* Prefer O(1) incremental state (boolean arrays) over re-scanning the board on every check — it turns an already-fast solution into a very fast one.		* Prefer O(1) incremental state (boolean arrays) over re-scanning the board on every check — it turns an already-fast solution into a very fast one.
	* Global arrays/variables are common in competitive programming for exactly this kind of state — avoids passing/copying containers on every recursive call.		* Global arrays/variables are common in competitive programming for exactly this kind of state — avoids passing/copying containers on every recursive call.

			[[Category:DSA]]
			[[Category:Backtracking]]

MediaWiki:Tabberneue-tabbertransclude-category

Admin — Thu, 03 Sep 2026 04:49:55 GMT

Created blank page

New page

MediaWiki:Tabberneue-tabber-category

Admin — Thu, 03 Sep 2026 04:49:46 GMT

Created blank page

New page

DSA/Chessboards and Queens

Admin — Thu, 03 Sep 2026 04:41:34 GMT

Show changes

DSA/Chessboards and Queens

Admin — Thu, 03 Sep 2026 04:38:17 GMT

Create Chessboard & Queens problem solution

New page

= Chessboard and Queens (CSES) =

'''Problem:''' Place 8 queens on an 8×8 chessboard so that no two queens attack each other. Some squares are ''reserved'' (marked with a star in the input) and cannot hold a queen. Count the number of valid placements.

== Why Is This a Recursion Problem? ==

There are two strong signals that point to recursion (specifically '''backtracking'''):

# '''No natural iterative solution.''' We're placing 8 queens, and the number of valid choices for queen ''k'' depends entirely on how queens 1..k-1 were placed. You'd need 8 nested for-loops, one per queen — and even that doesn't work cleanly, since the number of ''valid'' choices at each level changes dynamically.
# '''Tiny constraints.''' An 8×8 board is a dead giveaway. Constraints this small almost always mean the intended complexity is something like <code>O(2^n)</code> or <code>O(n!)</code> — both are hallmarks of brute-force / backtracking search.

== The Core Idea ==

Since we need exactly one queen per row (8 queens, 8 rows), we can place them '''row by row''':

* Write a recursive function <code>place(row)</code>.
* For the current row, try every column from 0 to 7.
* If the square is free (not reserved) and not attacked, place a queen there, recurse into <code>row + 1</code>, then '''undo the placement''' (this is the "backtrack" step) before trying the next column.
* If <code>row == n</code>, it means all 8 queens were placed successfully — increment the answer.

The undo step is critical: after exploring one branch, the board must be restored to its previous state so the next column can be tried cleanly.

== First Working Version: Brute-Force Attack Checks ==

The simplest (but slowest) way to check if a square is attacked is to literally scan:

* '''Upward''' in the same column, for an existing queen.
* '''Diagonally up-left''' (decrementing both row and column).
* '''Diagonally up-right''' (decrementing row, incrementing column).

This works, and on the actual 8×8 test case it's already fast (a couple of milliseconds), because the search space collapses quickly once conflicts are found. But it does unnecessary work — every single placement attempt re-scans the whole column and both diagonals.

== Optimizing: O(1) Attack Checks ==

Instead of scanning every time, keep track of which columns and diagonals are '''already occupied''' using boolean arrays, updated incrementally as queens are placed and removed.

=== Columns ===

Trivial — one boolean array indexed by column:

<syntaxhighlight lang="cpp">
vector<bool> colAttacked(n, false);
</syntaxhighlight>

=== Diagonals: The Grid Math Trick ===

This is the part worth internalizing, since it comes up in many other grid problems.

There are two diagonal directions on a grid, and each has a simple invariant:

'''Diagonal type 1 (↘ direction, i.e. going down-right / cells where row and column both increase together):'''

Take a 4×4 board and look at the diagonal containing (0,3), (1,2), (2,1), (3,0). Notice:

row + col = 3 '''for every cell on this diagonal'''

The next diagonal over — (1,3), (2,2), (3,1) — satisfies <code>row + col = 4</code>. In general:

: '''Two cells lie on the same "↘"-type diagonal if and only if <code>row + col</code> is the same for both.'''

This matches the geometric fact that a line of the form <code>y + x = constant</code> is a straight line tilted at 45°.

'''Diagonal type 2 (↙ direction):'''

Look at (1,0), (2,1), (3,2): here <code>row − col = 1</code> for all of them. In general:

: '''Two cells lie on the same "↙"-type diagonal if and only if <code>row − col</code> is the same for both.'''

'''The negative-index problem:''' <code>row − col</code> can be negative (e.g. row=0, col=7 gives −7), and arrays can't have negative indices. The fix is a constant offset: since the minimum possible value of <code>row − col</code> is <code>−(n−1)</code>, add <code>n − 1</code> to shift everything into the non-negative range:

index = row - col + (n - 1)

Both diagonal arrays need size <code>2n − 1</code> (for n=8, that's 15 — matching the fact that an 8×8 board really does have 15 diagonals in each direction).

== Final Code ==

<syntaxhighlight lang="cpp">
#include <bits/stdc++.h>
using namespace std;

int n = 8;
vector<string> grid;

vector<bool> colAttacked(8, false);
vector<bool> diag1Attacked(15, false); // indexed by row + col
vector<bool> diag2Attacked(15, false); // indexed by row - col + (n - 1)

long long answer = 0;

void place(int row) {
if (row == n) {
answer++;
return;
}
for (int col = 0; col < n; col++) {
if (grid[row][col] == '*') continue; // reserved square
if (colAttacked[col]) continue;
if (diag1Attacked[row + col]) continue;
if (diag2Attacked[row - col + n - 1]) continue;

// place queen
colAttacked[col] = true;
diag1Attacked[row + col] = true;
diag2Attacked[row - col + n - 1] = true;

place(row + 1);

// backtrack: undo placement
colAttacked[col] = false;
diag1Attacked[row + col] = false;
diag2Attacked[row - col + n - 1] = false;
}
}

int main() {
grid.resize(n);
for (auto &row : grid) cin >> row;

place(0);
cout << answer << endl;
}
</syntaxhighlight>

Note: it's '''not necessary''' to actually mark the square in <code>grid</code> as a queen ('Q'); the three boolean arrays already fully capture every constraint we need to check, so there's nothing to gain from also mutating the grid string.

== Complexity ==

* Row 0 has at most 8 choices, row 1 has at most 7 (one column already taken), and so on — giving a rough bound of '''O(n!)''', possibly with an extra factor of n from the per-row scan: '''O(n! · n)'''.
* In practice it's '''much faster''' than this bound suggests, because diagonal constraints prune the search tree aggressively. On the empty 8×8 board (the worst case, since nothing is reserved), the recursion has exactly '''92 leaves''' (the well-known number of solutions to the 8-queens problem) and runs in about a millisecond.
* This approach does '''not''' scale to large n (e.g. n = 1000). Placing n non-attacking queens under arbitrary reserved-square constraints is a much harder problem in general — for large boards you need entirely different techniques (or the instance may simply be intractable).

== What Is Backtracking? ==

'''Backtracking''' is the name for exactly this pattern: recursively try a choice, recurse further assuming that choice, and if a later step hits a dead end (no valid moves possible), '''undo the choice''' ("backtrack") and try the next alternative. The name comes from the fact that the recursion tree doesn't just go forward — it routinely retreats and retries.

Some useful mental models:

* It's the same technique behind '''Sudoku solvers''': try a digit, recurse, and if a contradiction is eventually reached, undo and try a different digit.
* Backtracking is typically used to find '''one valid solution''' (Sudoku) or to '''count all valid solutions''' (this problem) when there's no faster closed-form or DP approach — often because the problem is NP-hard in general.
* Backtracking problems are almost always about a "good enough" solution rather than a provably optimal one. There is nearly always room to add smarter pruning:
** Example: if you can detect ''before'' recursing that some later row has only one legal column left, you can propagate that constraint early and cut off huge unproductive branches. This kind of look-ahead pruning can make backtracking '''hundreds or even thousands of times faster''' — but it's an enhancement on top of the base algorithm, not a change to its fundamental structure.

== Key Takeaways ==

* Small constraints (like n = 8) are a strong hint that the intended solution is exponential/factorial-time backtracking.
* Always pair "make a move" with "undo the move" (backtrack) after the recursive call returns — this is what makes the search correct.
* For diagonal checks on a grid, remember:
** <code>row + col</code> is constant along one diagonal direction.
** <code>row − col</code> is constant along the other (add an offset of <code>n − 1</code> to keep indices non-negative).
* Prefer O(1) incremental state (boolean arrays) over re-scanning the board on every check — it turns an already-fast solution into a very fast one.
* Global arrays/variables are common in competitive programming for exactly this kind of state — avoids passing/copying containers on every recursive call.

Template:DailyJournalPreload

Admin — Thu, 03 Sep 2026 03:57:33 GMT

← Older revision		Revision as of 09:27, 3 September 2026
Line 1:		Line 1:
	== TODOs ==		== TODOs ==
	* {{{todos\|}}}		{{{todos\|}}}

	== Learnings ==		== Learnings ==

Private:Journal/2026/08/31

Admin — Tue, 01 Sep 2026 09:19:23 GMT

Admin deleted page Private:Journal/2026/08/31 content was: "== TODOs == [] Go through KT videos on FPM project [] Try to convince Suman for a better project == Learnings == * == Thoughts ==", and the only contributor was "Admin" (talk)

Main Page

Admin — Tue, 01 Sep 2026 09:18:23 GMT

← Older revision		Revision as of 14:48, 1 September 2026
Line 10:		Line 10:
	* [[Special:RecentChanges\|Recent changes]]		* [[Special:RecentChanges\|Recent changes]]
	* [[Special:AllPages\|Flat list of all pages]]		* [[Special:AllPages\|Flat list of all pages]]
	* [{{fullurl:Private:Journal/{{#time:Y}}/{{#time:m}}/{{#time:d}}\|veaction=edit&preload=Template:DailyJournalPreload}} Create today's note]		* [{{fullurl:Private:Journal/{{#time:Y\|+5 hours 30 minutes}}/{{#time:m\|+5 hours 30 minutes}}/{{#time:d\|+5 hours 30 minutes}}\|veaction=edit&preload=Template:DailyJournalPreload}}}} Create today's note]

Template:DailyJournalPreload

Admin — Mon, 31 Aug 2026 12:16:00 GMT

← Older revision		Revision as of 17:46, 31 August 2026
Line 5:		Line 5:
	* {{{learnings\|}}}		* {{{learnings\|}}}

	== ~~Notes~~ ==		== Thoughts ==
	{{{notes\|}}}		{{{notes\|}}}

Main Page

Admin — Mon, 31 Aug 2026 12:14:06 GMT

← Older revision		Revision as of 17:44, 31 August 2026
(2 intermediate revisions by the same user not shown)
Line 10:		Line 10:
	* [[Special:RecentChanges\|Recent changes]]		* [[Special:RecentChanges\|Recent changes]]
	* [[Special:AllPages\|Flat list of all pages]]		* [[Special:AllPages\|Flat list of all pages]]
	* [{{fullurl:Journal/{{#time:Y}}/{{#time:m}}/{{#time:~~Y-m-~~d}}\|~~action~~=edit&preload=Template:DailyJournalPreload}} Create today's note]		* [{{fullurl:Private:Journal/{{#time:Y}}/{{#time:m}}/{{#time:d}}\|veaction=edit&preload=Template:DailyJournalPreload}} Create today's note]

Journal/2026/08/2026-08-31

Admin — Mon, 31 Aug 2026 05:26:41 GMT

Admin deleted page Journal/2026/08/2026-08-31 content was: "== TODOs == * {{{todos|}}} == Learnings == * {{{learnings|}}} == Notes == {{{notes|}}}", and the only contributor was "Admin" (talk)

Main Page

Admin — Mon, 31 Aug 2026 05:23:36 GMT

← Older revision		Revision as of 10:53, 31 August 2026
Line 10:		Line 10:
	* [[Special:RecentChanges\|Recent changes]]		* [[Special:RecentChanges\|Recent changes]]
	* [[Special:AllPages\|Flat list of all pages]]		* [[Special:AllPages\|Flat list of all pages]]
			* [{{fullurl:Journal/{{#time:Y}}/{{#time:m}}/{{#time:Y-m-d}}\|action=edit&preload=Template:DailyJournalPreload}} Create today's note]

Template:DailyJournalPreload

Admin — Mon, 31 Aug 2026 05:23:26 GMT

Created page with "== TODOs == * {{{todos|}}} == Learnings == * {{{learnings|}}} == Notes == {{{notes|}}}"

New page

== TODOs ==
* {{{todos|}}}

== Learnings ==
* {{{learnings|}}}

== Notes ==
{{{notes|}}}

Private:Daily

Admin — Mon, 31 Aug 2026 05:19:34 GMT

Admin deleted page Private:Daily content was: "=== Daily Day Details ===", and the only contributor was "Admin" (talk)

DSA/CSES 2Knights

Admin — Mon, 31 Aug 2026 05:04:38 GMT

Created page with "== Non-Attacking Knights on a k×k Board == '''Problem.''' For every board size <math>k = 1, 2, \dots, n</math>, count the number of ways to place ''two'' knights on a <math>k \times k</math> chessboard so that they do not attack each other. The core is instead of calculating the possible combinations of placements which is confusing we can do ''total_possibilities - attacking_squares'' ---- === Step 1: Total ways to place two knights, ignoring attacks === A <math>k..."

New page

== Non-Attacking Knights on a k×k Board ==

'''Problem.''' For every board size <math>k = 1, 2, \dots, n</math>, count the number of ways to place ''two'' knights on a <math>k \times k</math> chessboard so that they do not attack each other.

The core is instead of calculating the possible combinations of placements which is confusing we can do ''total_possibilities - attacking_squares''

----

=== Step 1: Total ways to place two knights, ignoring attacks ===

A <math>k \times k</math> board has <math>k^2</math> squares. Placing two (identical, unlabeled) knights on two different squares is just "choose 2 squares out of <math>k^2</math>":

<math display="block">\binom{k^2}{2} = \frac{k^2(k^2-1)}{2}</math>

This is the total number of placements '''before''' removing the ones where the knights attack each other.

----

=== Step 2: Counting the attacking pairs ===

A knight standing at square <math>(x, y)</math> attacks any square that is offset by one of these 8 vectors:

{| class="wikitable"
|-
! Offset (dx, dy)
|-
| (1, 2) || (1, −2) || (−1, 2) || (−1, −2)
|-
| (2, 1) || (2, −1) || (−2, 1) || (−2, −1)
|}

Notice: in '''every''' one of these 8 vectors, the two numbers <math>|dx|</math> and <math>|dy|</math> are just 1 and 2 in some order, with some sign.

'''How many placements exist for one fixed offset (dx, dy)?'''

For the pair of squares <math>(x,y)</math> and <math>(x+dx, y+dy)</math> to both lie on the board, <math>x</math> has <math>k - |dx|</math> valid choices, and <math>y</math> has <math>k - |dy|</math> valid choices. So the count is:

<math>(k - |dx|)(k - |dy|)</math>

Since <math>\{|dx|, |dy|\} = \{1, 2\}</math> for all 8 vectors, this is always:

<math>(k-1)(k-2)</math>

(No need to clamp negative values to zero — if <math>k=1</math>, the factor <math>(k-1)=0</math> already kills the product; if <math>k=2</math>, the factor <math>(k-2)=0</math> does the same. The algebra takes care of small boards automatically.)

'''Summing over all 8 offsets''' gives the total number of ''ordered'' attacking pairs (i.e., "knight A attacks square B" counted separately from "knight B attacks square A"):

<math>8(k-1)(k-2)</math>

But an unordered ''pair'' of squares gets counted twice this way (once in each direction), so the number of unordered attacking pairs is:

<math>E(k) = \frac{8(k-1)(k-2)}{2} = 4(k-1)(k-2)</math>

----

=== Step 3: Subtract to get non-attacking pairs ===

<math>
\text{Answer}(k) = \binom{k^2}{2} - E(k) = \frac{k^2(k^2-1)}{2} - 4(k-1)(k-2)
</math>

----

=== Step 4: Simplify into one closed-form polynomial ===

Expand each piece separately.

'''First term:'''
<math>\frac{k^2(k^2-1)}{2} = \frac{k^4 - k^2}{2}</math>

'''Second term:'''
<math>4(k-1)(k-2) = 4(k^2 - 3k + 2) = 4k^2 - 12k + 8</math>

Put both over a common denominator of 2:

<math>
\text{Answer}(k) = \frac{k^4 - k^2}{2} - \frac{8k^2 - 24k + 16}{2}
= \frac{k^4 - k^2 - 8k^2 + 24k - 16}{2}
</math>

Combine like terms (<math>-k^2 - 8k^2 = -9k^2</math>):

<math>
\text{Answer}(k) = \frac{k^4 - 9k^2 + 24k - 16}{2}
</math>

----

=== Step 5: Sanity check against the example ===

{| class="wikitable"
|-
! k !! Answer(k)
|-
| 1 || 0
|-
| 2 || 6
|-
| 3 || 28
|-
| 4 || 96
|-
| 5 || 252
|-
| 6 || 550
|-
| 7 || 1056
|-
| 8 || 1848
|}

Matches the sample output exactly.

'''Intuition for k=1 and k=2:''' On a 1×1 board there's only one square, so you can't even place two knights (0 ways). On a 2×2 board, <math>\binom{4}{2}=6</math> pairs exist, and a knight move needs at least a 3-wide gap in one direction, so ''none'' of them attack — all 6 count.

----

=== Step 6: Implementation ===

Since the formula is closed-form, each answer is <math>O(1)</math> to compute, so the whole solution is <math>O(n)</math> — trivially fast for <math>n \le 10000</math>.

<syntaxhighlight lang="python">
def f(k):
return (pow(k, 4) - 9 * pow(k, 2) + 24 * k - 16) // 2

n = int(input())

for i in range(1, n + 1):
print(f(i))
</syntaxhighlight>

'''Note:''' the division by 2 is safe as integer division (<code>//</code>) because <math>k^4 - 9k^2 + 24k - 16</math> is always even — this follows directly from the derivation, since it came from summing two integer-valued combinatorial counts (<math>\binom{k^2}{2}</math> and <math>E(k)</math>) that are each themselves always integers, and their difference stays an integer after the <math>\times 2</math> common denominator was cleared.

[[Category:DSA]]

CSES/Introductory/Weird Algorithm

Admin — Sun, 30 Aug 2026 09:01:41 GMT

Admin deleted page CSES/Introductory/Weird Algorithm content was: " Just use Brute Force using while loop <syntaxhighlight lang="python3" line="1"> n = int(input()) while n != 1: print(n, end=' ', flush=True) if n % 2 != 0: n = n*3 + 1 else: n = n // 2 print(n) </syntaxhighlight>", and the only contributor was "Admin" (talk)

CSES/Introductory/Missing Number

Admin — Sun, 30 Aug 2026 09:01:31 GMT

Admin deleted page CSES/Introductory/Missing Number content was: " For a number series from 1 to n the sum is <math>sum = (n * (n+1))/2</math> so the missing number must be <math>sum - input\_sum</math> <syntaxhighlight lang="python3" line="1"> n = int(input()) nums = map(int, input().split()) print((n * (n + 1) // 2) - sum(nums)) </syntaxhighlight>", and the only contributor was "Admin" (talk)

Private:Daily/27Aug2026

Admin — Thu, 27 Aug 2026 09:18:27 GMT

Admin deleted page Private:Daily/27Aug2026 content was: "== TODOS == [] Revise all topics from the week 1 on boarding plan [] Revise python for DSA [] Start working on CSES problems == LEARNINGS ==", and the only contributor was "Admin" (talk)

Private:Daily/26Aug2026

Admin — Thu, 27 Aug 2026 09:18:15 GMT

Admin deleted page Private:Daily/26Aug2026 content was: "# Learned about multiple AWS services # Attended sessions on TOPS 2 application and team norms == TODOS == [x] Create a skill for AI FDE design tokens and patterns [x] Create a skill for AI FDE to make a PPT", and the only contributor was "Admin" (talk)

Private:Daily/25Aug2026

Admin — Thu, 27 Aug 2026 09:18:10 GMT

Admin deleted page Private:Daily/25Aug2026 content was: "# Learned about something related to TOPS2 # Completed the design for POC of IQE agents == TODOS == [x] Complete the design for IQE POC [x] extract the design theme and tokens for CBRE emarald theme", and the only contributor was "Admin" (talk)

Private:Daily/24Aug2026

Admin — Thu, 27 Aug 2026 09:18:02 GMT

Admin deleted page Private:Daily/24Aug2026 content was: " # Created an IQE generic Agent but haven't tested on anything but introduced many methodologies and stuff into it to make it efficient and better # Revised Python, React, Typescript [x] Complete draft of IQE agent. [] Research about Life Sciences companies", and the only contributor was "Admin" (talk)

Private:Daily/21Aug2026

Admin — Thu, 27 Aug 2026 09:17:58 GMT

Admin deleted page Private:Daily/21Aug2026 content was: "# Worked on QE Agent POC with 2 different approaches #* First approach is to do based on the human decided goals and testing that but not complete the full requirement #* Second approach is to get GitHub issues, PR and then crawl around then test the quality but the issue is scope not definable properly and getting more complex", and the only contributor was "Admin" (talk)

Private:Daily/20Aug2026

Admin — Thu, 27 Aug 2026 09:17:54 GMT

Admin deleted page Private:Daily/20Aug2026 content was: " # Learned about ontology functions. # Started to work on Autonomous QE Agent POC, doesn't know whether it's going to be a success or not but using all the techniques and methodologies I know for better efficiencies. == TODOS == [x] Create a comprehensive research document on QE Agent creation -> Think about harness of context in loops/iterations. [x] Learn Ontology functions [...", and the only contributor was "Admin" (talk)

Private:Daily/19Aug2026

Admin — Thu, 27 Aug 2026 09:17:50 GMT

Admin deleted page Private:Daily/19Aug2026 content was: "# Learned about ontology creation, object creations, workspace creations # Got to know about the CBRE AI Agent integration little bit. Seems like they are facing issues with QE Agents #* The proposed solution is not a straight forward because first I need to understand how exactly their agents are working are they just sending the code to models and writing some prompts and getting...", and the only contributor was "Admin" (talk)

Private:Daily/18Aug2026

Admin — Thu, 27 Aug 2026 09:17:42 GMT

Admin deleted page Private:Daily/18Aug2026 content was: "* Started Exploring what is Palantir, ontology and other stuff * Got the Palantir and GitHub copilot access EOD", and the only contributor was "Admin" (talk)

Private:Daily/17Aug2026

Admin — Thu, 27 Aug 2026 09:17:34 GMT

Admin deleted page Private:Daily/17Aug2026 content was: "#REDIRECT Private:Daily/2026/August/17", and the only contributor was "Admin" (talk)

Private:Daily/2026/August/17

Admin — Thu, 27 Aug 2026 09:17:02 GMT

Admin deleted page Private:Daily/2026/August/17 content was: "* Got on boarded into CBRE * Collected Laptop from Rajan * Start setting up some basic essentials in laptop", and the only contributor was "Admin" (talk)

Private:Daily/17Aug2026

Admin — Thu, 27 Aug 2026 09:16:37 GMT

Admin moved page Private:Daily/17Aug2026 to Private:Daily/2026/August/17

Private:Daily/2026/August/17

Admin — Thu, 27 Aug 2026 09:16:37 GMT

Admin deleted page Private:Daily/2026/August/17 Deleted to make way for move from "Private:Daily/17Aug2026"

Private:Daily/Daily

Admin — Mon, 24 Aug 2026 10:26:00 GMT

Admin deleted page Private:Daily/Daily content was: "=== Daily Day Details ===", and the only contributor was "Admin" (talk)

← Older revision		Revision as of 09:29, 11 September 2026
(One intermediate revision by the same user not shown)
Line 10:		Line 10:
	* [[Special:RecentChanges\|Recent changes]]		* [[Special:RecentChanges\|Recent changes]]
	* [[Special:AllPages\|Flat list of all pages]]		* [[Special:AllPages\|Flat list of all pages]]
	* [{{fullurl:Private:Journal/{{~~#time:Y\|+5 hours 30 minutes~~}}/{{~~#time:m\|+5 hours 30 minutes~~}}/{{~~#time:d\|+5 hours 30 minutes~~}}\|~~veaction~~=edit&preload=Template:DailyJournalPreload}}}} Create today's note]		* [{{fullurl:Private:Journal/{{LOCALYEAR}}/{{LOCALMONTH}}/{{LOCALDAY2}}\|action=edit&preload=Template:DailyJournalPreload}} Create today's note]

← Older revision		Revision as of 14:48, 1 September 2026
Line 10:		Line 10:
	* [[Special:RecentChanges\|Recent changes]]		* [[Special:RecentChanges\|Recent changes]]
	* [[Special:AllPages\|Flat list of all pages]]		* [[Special:AllPages\|Flat list of all pages]]
	* [{{fullurl:Private:Journal/{{#time:Y}}/{{#time:m}}/{{#time:d}}\|veaction=edit&preload=Template:DailyJournalPreload}} Create today's note]		* [{{fullurl:Private:Journal/{{#time:Y\|+5 hours 30 minutes}}/{{#time:m\|+5 hours 30 minutes}}/{{#time:d\|+5 hours 30 minutes}}\|veaction=edit&preload=Template:DailyJournalPreload}}}} Create today's note]

← Older revision		Revision as of 17:44, 31 August 2026
(2 intermediate revisions by the same user not shown)
Line 10:		Line 10:
	* [[Special:RecentChanges\|Recent changes]]		* [[Special:RecentChanges\|Recent changes]]
	* [[Special:AllPages\|Flat list of all pages]]		* [[Special:AllPages\|Flat list of all pages]]
	* [{{fullurl:Journal/{{#time:Y}}/{{#time:m}}/{{#time:~~Y-m-~~d}}\|~~action~~=edit&preload=Template:DailyJournalPreload}} Create today's note]		* [{{fullurl:Private:Journal/{{#time:Y}}/{{#time:m}}/{{#time:d}}\|veaction=edit&preload=Template:DailyJournalPreload}} Create today's note]

← Older revision		Revision as of 10:53, 31 August 2026
Line 10:		Line 10:
	* [[Special:RecentChanges\|Recent changes]]		* [[Special:RecentChanges\|Recent changes]]
	* [[Special:AllPages\|Flat list of all pages]]		* [[Special:AllPages\|Flat list of all pages]]
			* [{{fullurl:Journal/{{#time:Y}}/{{#time:m}}/{{#time:Y-m-d}}\|action=edit&preload=Template:DailyJournalPreload}} Create today's note]