Output 5-line calendar

Given year, month and optionally weekday of 1st, output the calendar of the month.

For empty cell, fill it with the date where it's supposed to be, in last or next month, and add # to indicate gray. If last few days can't fit in 5 lines, then they share last line with 5th week, use / to separate two days.

Sample Input: Nov 2023

Sample Output:

 #28   #29   #30     1     2     3     4
   5     6     7     8     9    10    11
  12    13    14    15    16    17    18
  19    20    21    22    23    24    25
  26    27    28    29    30    #1    #2

Sample Input: Dec 2023

Sample Output:

 #26   #27   #28   #29   #30     1     2
   3     4     5     6     7     8     9
  10    11    12    13    14    15    16
  17    18    19    20    21    22    23
24/31   25    26    27    28    29    30

Outputting a 2D array of string is fine

Longest irreducible quine

Posted here

How long is this string, really?

answer-chaining cops-and-robbers

In this challenge answers will provide three elements:

• A programming language: \$L\$
• An output string: \$S\$
• And a non-empty string: \$B_n\$

You will also write, but not reveal, a program in \$L\$ which outputs \$S\$, built by concatenating copies of the \$B_n\$ strings from your answer and previous answers in any order.

For example here are two answers given in pseudocode:

Answer 1

\$S\$ = H
\$B_0\$ = print "H"

The program is print "H"

Answer 2

\$S\$ = Hiiii
\$B_1\$ = ++"i"

The program is print "H"++"i"++"i"++"i"++"i"

Robbers will try to discover a valid solution, that is a program made from the \$B_n\$ strings in your answer and previous answers which outputs your \$S\$. Your goal will be to make this as hard as possible.

States

As with any cops-and-robbers challenge, cops' posts here can have 4 different states:

• Vulnerable
• Cracked
• Safe
• Revealed

All cops' posts start as vulnerable. If a robber finds and posts a solution to a vulnerable post they will receive 1 point and the post will become cracked. If a post lasts 10 days in vulnerable without being solved it automatically becomes safe. A cop with a safe post may choose to reveal their program and their safe post will become revealed. A robber can still solve a safe post, if they do they receive a point and the post becomes revealed.

Only revealed posts are eligible for scoring. Robbers are only permitted to solve vulnerable and safe posts.

Scoring

For cops' an answer's score is the number of cops' posts before it if it is revealed and 0 if it is any other state. The goal is to get as high a score as possible.

Languages

In the interest of fairness, we are going to require that languages are free and reasonably cross platform. Both languages you choose must be freely available on Linux and FreeBSD (the two largest foss operating systems). This includes languages which are free and open source.

Your selected languages must predate this challenge.

Programs here should be complete programs not functions, expressions or snippets.

How many cacti can I plant here?

Draw a Fibonacci Swoosh

Scroll That Text Faster!

Lots of television news stations will show a ticker at the bottom, which can be thought of as a window into a larger string that shifts to the right by one space each cycle:

"Lorem ipsum dolor sit amet, consectetur adipiscin"
"orem ipsum dolor sit amet, consectetur adipiscing"
"rem ipsum dolor sit amet, consectetur adipiscing "
"em ipsum dolor sit amet, consectetur adipiscing e"
"m ipsum dolor sit amet, consectetur adipiscing el"

This works great if the cycle time is short and the text can scroll by quickly. But not every updating text application is so lucky. Radio Data System is used by FM radio stations to send small amounts of data, about 1.2 kilobits per second, which contains information about the station or song or what-have-you. But with such a low bitrate, updates can be quite slow, and stations I see update the text about once a second.

With small enough windows, this can be annoyingly slow if we only advance it one character at a time. But some stations use a trick: separate the message by spaces and fit as many as we can into one window. Any words longer than the window must be scrolled one character at a time.

The Challenge

Write a function f(s, w) where s is the full string to scroll through and w is the size of the window in characters. w must be an integer and greater than 0. The output is a sequence of strings (array or output to console separated by newlines or whatnot), where each line is one step of the ticker.

To build the output, we can divide the words into those that fit into the window and those that don't. Of the first kind, fit as many as you can into one window, ignoring trailing spaces. If a word is exactly 1 window wide, it is considered of the first kind. If we get to a word that doesn't fit in the window but we still have empty space in the current window, just leave the rest of the window blank.

For words that don't fit in the window, scroll through them one character at a time until the end of the word is visible as the last character of the window. Each scroll step becomes its own output line. Words that don't fit in the window never share windows with those that do - the output shouldn't be "NEVER GON", "NA ", it should be "NEVER ", "GONNA ".

Examples

s = "RICK ASTLEY - NEVER GONNA GIVE YOU UP", w = 10

 0123456789
"RICK      "
"ASTLEY -  "
"NEVER     "
"GONNA GIVE"
"YOU UP    "

s = "LUDWIG VAN BEETHOVEN - SYMPHONY NO. 7 IN A MAJOR, OP. 92", w = 6

 012345
"LUDWIG"
"VAN   "
"BEETHO"
"EETHOV"
"ETHOVE"
"THOVEN"
"-     "
"SYMPHO"
"YMPHON"
"MPHONY"
"NO. 7 "
"IN A  "
"MAJOR,"
"OP. 92"

s = "SHERMAN BROTHERS - SUPERCALIFRAGILISTICEXPIALIDOCIOUS", w = 15

 012345678901234
"SHERMAN        "
"BROTHERS -     "
"SUPERCALIFRAGIL"
"UPERCALIFRAGILI"
"PERCALIFRAGILIS"
"ERCALIFRAGILIST"
"RCALIFRAGILISTI"
"CALIFRAGILISTIC"
"ALIFRAGILISTICE"
"LIFRAGILISTICEX"
"IFRAGILISTICEXP"
"FRAGILISTICEXPI"
"RAGILISTICEXPIA"
"AGILISTICEXPIAL"
"GILISTICEXPIALI"
"ILISTICEXPIALID"
"LISTICEXPIALIDO"
"ISTICEXPIALIDOC"
"STICEXPIALIDOCI"
"TICEXPIALIDOCIO"
"ICEXPIALIDOCIOU"
"CEXPIALIDOCIOUS"

Notes

• Words are defined as any sequence of non-space characters between space characters, at least U+0020. Word delimiters aren't dashes, commas, or punctuation.
• ASCII support only is fine, though you can get bonus style points if it supports a broader selection of Unicode, including fancy Unicode whitespace.
• Supporting uppercase-only, lowercase-only, or mixed case is fine.
• Trailing whitespace in output strings to pad to the window width is optional.
• This is code golf, so smallest program (bytes, codels, etc.) wins!

Count trapped self-avoiding walks fastest-code path-finding

Imagine an infinite grid of square tiles. You are standing on one of the tiles. You can move to any of the four cardinally adjacent tiles in a move, but you cannot step on the same tile twice. Calculate the number of ways you can get yourself trapped, i.e. the states where all four adjacent tiles have been already stepped on, after exactly \$n\$ moves. To take symmetry into account, only count the paths where your first move is to the right, and your first vertical move is upwards.

This is sequence A077482:

1, 2, 11, 25, 95, 228, 752, 1860, 5741, 14477, 42939, 109758,
317147, 818229, 2322512, 6030293, 16900541, 44079555, 122379267,
320227677, 882687730, 2315257359, 6346076015, 16675422679,
45502168379, 119728011251, 325510252108, 857400725204, ...

This is a fastest-code challenge. Submit a program that outputs the answers to the question for \$n = 7, 8, 9, 10, \cdots\$, indefinitely. The score of a submission will be the largest \$n\$ whose answer is printed in a minute on my local machine. Highest score wins; tie is broken by the time taken to output up to that term.

My local machine is a Windows 10 machine with the following specs:

• CPU: 12th Gen Intel Core i7-12700 (2.1GHz, 12 cores)
• RAM: 32GB

If a submission has no way to run on Windows, you can provide your own measurement, or online code execution services such as TIO/ATO/Godbolt may be used. I know this is not ideal, but I don't have other good options at the moment.

Sorting with a deque

Given an integer \$n\$. Connect all pairs of points on \$\mathbb Z^2\$ whose distance is \$\sqrt n\$. Count how many connected sets remain.

In case that infinite sets exist, return something not a positive integer. (0 used below)

Test cases

1 => 1
2 => 2
3 => 0
4 => 4
5 => 1
25 => 1

Shift right by half a trit

Completely introduce your friends

Visualize "Destroying Democracy" code-golf grid

This MathPickle post poses an interesting problem about gerrymandering.

An n-by-n square grid is given, and all cells are initially painted green. You can paint some cells red and partition the grid into several rectangles. The color of a rectangle is red if there are strictly more red cells than green; otherwise it is green (including when the numbers are equal). Your objective is to "win the election" by having strictly more red rectangles than green, with as few red cells as possible.

• The rectangles must cover the grid, and may not overlap.
• The largest rectangle's area must be strictly less than twice the smallest.

This problem has been solved for n <= 12 in this Puzzling post, and for more sizes in this OEIS entry.

Some examples: (same letter = one rectangle, uppercase = red)

n = 3: 4 red cells
AAa
BBb
ccc

n = 4: 6 red cells
AAad
BBbd
CCcd
eeee

n = 5: 8 red cells
AAafg
BBbfg
CCcfg
DDdfg
eeefg

n = 6: 11 red cells
aaaaad
bEFGHd
bEFGHd
befghd
bIIIid
bccccc

In this challenge, you don't need to minimize the number of red cells. Instead, find any one way to win the election by painting \$\frac{n^2}{2}\$ or fewer cells red and partitioning the grid following the rules.

I/O

The input is one integer n which is at least 3.

The output must be a 2D structure with n rows and n columns, where each item identifies the color and the rectangle the cell belongs to. The following are some valid outputs for n = 3:

2D array of nonzero integers, where sign = color and absolute value = rectangle ID
[[-1, -1, 1],
 [-2, -2, 2],
 [3, 3, 3]]

2D array of tuples of (bool, string)
[[(false, "A"), (false, "A"), (true, "A")],
 [(false, "B"), (false, "B"), (true, "B")],
 [(true, "C"), (true, "C"), (true, "C")]]

Strings printed over n lines
R1 R1 G1
R2 R2 G2
G3 G3 G3

Note that the "letter representation" used above is for illustration purposes and not allowed, since the number of rectangles can go over 26.

Standard code-golf rules apply. The shortest code in bytes wins.

Stuck on Sokoban

Is it a date format of YYMMDD, MMDDYY, and/or DDMMYY?

code-golf decision-problem date

Print 4 billion if statements

Draw a string as a binary tree

How many dots are there?

Implement a very tiny APL dialect

In this challenge, you implement a small variant of APL. The core feature of APL is multidimensional arrays, which are a generalization over scalars, vectors, matrices, 3d arrays, .... This challenge has intentionally lax requirements in some places and more strict ones in others to make the challenge more interesting. In this APL, all arrays only contain integers of a size suitable for your language. If you want to limit the amount of axes (i.e. the rank) of an array, this limit should at least be 10.

Concepts

The shape of an array is the amount of things on each axis: for example the scalar 1 has shape [], the vector [1, 2, 3] has shape [3], a 2x3 matrix has shape [2, 3].

Array literals

There should be a way to write an array literal, no matter its dimension. This can be done in many ways: a binary function (see below) like 3 2 makeArray 1 2 3 4 5 6, syntax specifying shape and contents like [3 2; 1 2 3 4 5 6], by providing a syntax for scalars like 1, a syntax for vectors like (1 2 3) and a syntax for combining arrays creating a new axis like [(1 2 3) (4 5 6)]. The rest of the challenge uses the latter syntax. You can choose to provide a syntax for negative numbers or just use negation (see below) to construct them.

Functions

You should provide the following functions: addition, negation, subtraction, shape. You can choose any name for these functions, but the ones for negation and subtraction must be the same and only distinguishable by context (see below). Negation negates each integer contained in the array. Addition and subtraction respectively add and subtract each item in the array, when they have the same shape; if one of the two arrays is a scalar all the values of the other arrays are operated with that scalar; otherwise the result is undefined. Shape always returns a vector containing the shape of the argument.

Examples

1 + 1                                    → 2
(1 2 3) + (4 5 6)                        → (5 7 9)
[(1 2 3) (4 5 6)] + [(1 1 1) (-1 -1 -1)] → [(2 3 4) (3 4 5)]
(1 2 3) + 5                              → (6 7 8)
(1 2) + (3 4 5)                          → undefined
(1 2 3) + [(4 5 6)]                      → undefined
(1 2 3) - (9 3 1)                        → (-8 -1 2)
-[(1 2 3) (4 5 6)]                       → [(-1 -2 -3) (-4 -5 -6)]
shape 2                                  → ()
shape (1 2 3)                            → (3)
shape [(1 2 3) (4 5 6)]                  → (2 3)

Reduce

You should also support reduction. Reduction is written after a binary function (so addition or subtraction) and reduces the first axis of an array right to left. This means that an array of shape [2, 4, 7] becomes [4, 7]. Addition reduce sums all subarrays, subtraction reduce does an alternate sum of the subarrays. Note that you may not provide a function for "add reduce" and another for "minus reduce"; in other words the syntax for add reduce and subtract reduce should respectively have a prefix of the syntax for add and subtract and share a common suffix, where the prefixes and the suffix together constitute the whole function name, ignoring whitespace. Reducing over an empty axis is undefined; reducing over a scalar returns that scalar.

Examples

+ reduce (1 2 3)           → 6
+ reduce [(1 2 3) (4 5 6)] → (5 7 9)
+ reduce 5                 → 5
+ reduce ()                → undefined
- reduce (1 2 3)           → 2

Syntax

The only thing missing is a way to combine expressions. Unary functions consume all the expression to the right as the argument; binary functions do the same for the right argument but only consume the value directly to the left of the function name. Grouping syntax using an opening and closing sequence must also be supported, this can go to the left of a binary function to give it a more complex left argument or around other expressions with no meaning. Grouping around functions or the reduction symbol is not required. Using an unary function as a binary function or vice versa is undefined.

Examples

In these examples, {/} is the grouping syntax.

1 + 2 - 3       → 1 + {2 - 3}         → 0
1--3            → 1-{-3}              → 4
shape +/(1 2 3) → shape {+/{(1 2 3)}} → shape 6 → ()
+5              → undefined
3 shape 2       → undefined

Make an almost-square

How many 2x4s can you make from a log?

code-golf geometry

You have a pile of logs that you want to mill into two-by-four inch boards to build a new stand for your grilled-cheese sandwich business. You've counted and measured all the logs, but can you get all the lumber you need out of them?

Challenge

code-golf a program to find the number of two-by-fours you can make from a log, given the diameter of the log.

Details

Milling the logs is a two-step process: First, you cut the log into a number of parallel 2-inch planks, discarding 1 inch on either end. For example, you would get four live-edge 2-inch-thick planks from a 10-inch-diameter log (not including bark):

Then, you cut each plank into as many 4-inch wide boards as you can. Each board must be a full 4 inches on each side, i.e., you may not cut past the corner of the plank on either side.

Fortunately, every log is perfectly cylindrical, untapered, and has a diameter that is a multiple of 2 inches, and you have a saw with an infinitesimal kerf.

Input

The diameter of the log in inches. Always a positive multiple of 2.

Output

The number of two-by-fours you can make from a log of the given diameter.

Test cases

 Input Output
     2      0
     6      2
    10      6
    14     12
    20     30
    30     74

Convert a parent vector to a depth vector

Slanted Letter Sign

code-golf string ascii-art

I dreamed I opened a business called “The Skill Share” and the sign out front looked (sort of) like this:

      L E
     L R
  E I A
 H K H
T S S

Write a program or function that formats text like this.

Input

The input will be a non-empty string of printable ASCII characters. The only whitespace will be single, non-leading, non-trailing spaces. You may take input in any reasonable format.

Output

The output may be in any reasonable format. When printed, each word (contiguous substring of non-space characters) of the input should start on the bottom row and each character in the word should be up and to the right of the previous character by one position. The second word, if there is one, should start on the bottom row two positions to the right of the first, and so on. Leading and trailing whitespace are allowed.

Rules

• Default I/O rules and standard rules apply. Standard loopholes are forbidden.

Examples

1. Input

   CHEESE & JAM
   

   Output

        E
       S
      E
     E   M
    H   A
   C & J
   

2. Input

   Code Golf!
   

   Output

         !
      e f
     d l
    o o
   C G
   

3. Input

   This is the end
   

   Output

      s
     i   e d
    h s h n
   T i t e
   

Sandbox questions

• Similar challenges/duplicates?

Add sets of roots of two polynomials

Objective

Given two positive-degree polynomials with integer coefficients, output the polynomial whose roots are sums of the roots of the inputted polynomials.

Note that the outputted polynomial may have repeated roots, so may the inputted polynomials. As a consequence, provided that the degrees of the inputted polynomials are \$r\$ and \$s\$, the outputted polynomial has the degree of \$r \times s\$.

I/O format

It is assumed that each I/O-ed polynomial has coefficients that are coprime altogether (that is, have GCD of \$1\$ overall) and has a positive-coefficient leading term. Otherwise flexible.

Examples

Here, the binary operator in question is denoted \$\oplus\$.

• \$x \oplus x = x\$
• \$x \oplus x^2 = x^2\$
• \$(x-1) \oplus (x-1) = x-2\$
• \$(x+1) \oplus (x-1) = x\$
• \$(x-1) \oplus (2x+1) = 2x-1\$
• \$\left(x^2+1\right) \oplus (x-1) = x^2-2x+2\$
• \$\left(x^3-1\right) \oplus (2x-1) = 8x^3-12x^2+6x-9\$
• \$\left(x^4+2x^2+1\right) \oplus (x-1) = x^4-4x^3+8x^2-8x+4\$
• \$\left(x^2-x+1\right) \oplus \left(x^2+x+1\right) = x^4+3x^2\$

CSV version:

Input 1, Input 2, Output

[1, 0], [1, 0], [1, 0]
[1, 0], [1, 0, 0], [1, 0, 0]
[1, -1], [1, -1], [1, -2]
[1, 1], [1, -1], [1, 0]
[1, -1], [2, 1], [2, -1]
[1, 0, 1], [1, -1], [1, -2, 2]
[1, 0, 0, -1], [2, -1], [8, -12, 6, -9]
[1, 0, 2, 0, 1], [1, -1], [1, -4, 8, -8, 4]
[1, -1, 1], [1, 1, 1], [1, 0, 3, 0, 0]

Worked example

For look at the last example above: \$\left(x^2-x+1\right) \oplus \left(x^2+x+1\right)\$.

The roots of \$x^2-x+1\$ is \$\left(1 \pm \sqrt{3}i\right)/2\$, while the roots of \$x^2+x+1\$ is \$\left(-1 \pm \sqrt{3}i\right)/2\$. Thus, the roots of \$\left(x^2-x+1\right) \oplus \left(x^2+x+1\right)\$ are:

• \$\left(1 + \sqrt{3}i\right)/2 + \left(-1 + \sqrt{3}i\right)/2 = \sqrt{3}i\$, and
• \$\left(1 + \sqrt{3}i\right)/2 + \left(-1 - \sqrt{3}i\right)/2 = \left(1 - \sqrt{3}i\right)/2 + \left(-1 + \sqrt{3}i\right)/2 = 0\$, and
• \$\left(1 - \sqrt{3}i\right)/2 + \left(-1 - \sqrt{3}i\right)/2 = -\sqrt{3}i\$.

Thus, \$\left(x^2-x+1\right) \oplus \left(x^2+x+1\right) = x^2 \left(x - \sqrt{3}i\right) \left(x + \sqrt{3}i\right) = x^4 + 3x^2\$.

Computing Pi with iF*ck

pi math number number-theory open-ended-function

Now live here!

Convert romanji to hiragana, one letter at a time (draft)

code-golfinteractivenatural-language

Duolingo's Japanese course has exercises for kanji where you type the pronunciation of kanji in romanji. As you type, romanji is replaced with hiragana as you type:

[demo]

Write the shortest program or function that replicates this behavior.

Specification

Input/Output

• Input will be exclusively from STDIN, one ASCII character at a time.
• Input will only contain ASCII [a-z].
• The input/output should be displayed on the screen as it is typed.
• The display is not flexible: you must have it be on a single, self-overwriting updating line.

Behavior

• When typed, input letters should remain until the program detects a valid hiragana. Once it does, those letters should be replaced with the hiragana.
• Double consonants should be replaced with small tsu っ.

Romanji to Hiragana

[table]

Worked examples

These examples will have the format romanji => hiragana, with following lines being the what program the program should display as the user types the romanji.

konnichiwa => こんにちわ
k
こ
こn
こんn
こんに
こんにc
こんにch
こんにち
こんにちw
こんにちわ

chikai => ちかい
c
ch
ち
ちk
ちか
ちかい

yatta => やった
y
や
やt
やtt
やった

bocchizarokkyu => ぼっちざろっきゅ
b
ぼ
ぼc
ぼcc
ぼcch
ぼっち
ぼっちz
ぼっちざ
ぼっちざr
ぼっちざろ
ぼっちざろk
ぼっちざろkk
ぼっちざろkky
ぼっちざろっきゅ

gyuunyuu => ぎゅうにゅう
g
gy
ぎゅ
ぎゅう
ぎゅうn
ぎゅうny
ぎゅうにゅ
ぎゅうにゅう

Identify Redundant Regex

Translate BBCode into HTML

Sort the Test Tubes

Huffman Decoding

Write a programm which takes two strings as input and prints a text.

The first argument is a Huffman Tree, serialized in the following format:

• every ascii character except ~ is always a leaf, if ~ is the first characater it is also a leaf.
• <tree0><tree1>~ is a tree where <tree0> is the left subtree and <tree1> is the right subtree.

Example: ab~cde~~~ generates this tree:

 ┌─┴─┐
┌┴┐ ┌┴─┐
a b c ┌┴┐
      d e

where a would have the key 00, b 01, c 10, d 110 and e the key 111.

The second argument is a text that has been compressed with with the Huffman code that is defined by the first parameter. This bit-string can contain any bit sequence (also null-bytes and non-printable characters) and is not byte aligned, therefore it has been encoded with a variation of the standard Base64 encoding:

• the characters used for the encoding are the standard base64 characters: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
• the bitstring is broken up into 6-bit chunks and mapped to this characters
• if the last chunk is smaller than 6 bits, a character with this prefix is used, and padding characters are added to the string:
• - : the last chunk was five bits long
• = : the last chunk was four bits long
• =- : the last chunk was three bits long
• == : the last chunk was two bits long
• ==- : the last chunk was one bit long

Example:

bits:       1 1 1 1 0 1 1 0 1 0 0 1 1 1 0 1 0 1 0 0 0 1 1 0 1
chunks:    |1 1 1 1 0 1|1 0 1 0 0 1|1 1 0 1 0 1|0 0 0 1 1 0|1[0 0 0 0 0]|
characters:       9           p           1           G           g
base64:     9p1Gg==-

Your programm has to decode the text encoded in the second parameter and print it to stdout.

You have to provide your source code encoded in the way described above. The length of your encoded source code + the length of your serialized huffman tree will be the winning criterion.

TODO: example input