text:
Counting Moufang Loops
A loop is a pretty simple algebraic structure.  It is a tuple (G,+) where G is a set and + is a binary operator G × G → G.  That is + takes two elements from G and returns a new element.  The operator is also required to fulfill two properties

Cancellation: For every a and b in G there exists unique x and y in G such that
a + x = b
y + a = b

Identity: There is an e in G such that for every a in G
e + a = a
a + e = a

If you are familiar with the concept of a group you might notice that a loop is just a group that doesn't have an associative property.
Loops are pretty simple so people like to add more rules to make new structures that are more interesting.  One such structure is a Moufang loop which is a loop that also satisfies the following four identities forall x, y and z in G
z + (x + (z + y)) = ((z + x) + z) + y
((y + z) + x) + z = y + (z + (x + z))
(z + x) + (y + z) = (z + (x + y)) + z
(z + x) + (y + z) = z + ((x + y) + z)

For example the following Cayley table represents a Moufang loop:
0  1  2  3
1  0  3  2
2  3  0  1
3  2  1  0

(If you are not familiar a Cayley table is a square matrix M where Mi,j is equal to i + j.  It is a handy way for representing binary operators on a set.)
We can show that there is an identity rather easily it is 0.  Cancellation is a little harder to show but a brute force approach yields this table
b a → 0 1 2 3
↓
0     0 1 2 3
1     1 0 3 2
2     2 3 0 1
3     3 2 1 0

Where our elements are the solutions to
a + x = b = x + a

(You may notice that this table is identical to our Cayley table.  I'll leave it as an exercise to the reader to figure out why this is the case for this Moufang loop)
Now we need to verify the Moufang identities for our structure.  There are two ways to do this for the particular structure the first way is to realize that it is associative and thus automatically fulfills the criteria, however this will not work in general so we would rather brute force the result.  There are 3 free variables each with a potential of 4 values in every expression here.  This means we have to perform 7*43 or 448 computations.  I'll leave out the raw computations but here is some Haskell you can use to verify this.
Task
Given a positive integer n as input output the number of Moufang loops that have order n.  (the order of a group is the size of the set)
This is code-golf so answers will be scored in bytes with fewer bytes being better.
Test cases
Here is the number of Moufang loops for the first 71 inputs
1,1,1,2,1,2,1,5,2,2,1,6,1,2,1,19,1,5,1,6,2,2,1,20,2,2,5,5,1,4,1,122,1,2,1,18,1,2,2,19,1,7,1,5,2,2,1,103,2,5,1,6,1,17,2,17,2,2,1,18,1,2,4,4529,1,4,1,6,1,4,1

What is "G × G"?

@EriktheOutgolfer The direct product of G and G its the set of all pairs of elements of G, this basically says that + takes two things from G and returns a thing in G

I downvoted this challenge, because the mathematics involved is quite fluffy and not accessible to everyone who reads this challenge. Perhaps, a worked example would be helpful (like, explaining why the the 8th input results in 5)? If you add one I think I will retract my vote, but of course that is up to you.

@IanGödel Could you clarify what you mean by fluffy?  It is certainly a more advanced mathematical topic but I don't think that we should shy away from math on PPCG.  I'll add a worked example of a Moufang loop, but calculating an entire input by hand would probably clutter the challenge.

@WheatWizard "Fluffy" as in, perhaps, "Advanced". EDIT: I retracted the downvote, but still awaiting an example.

Every group is clearly a moufang loop, but it would be nice to have a non-group example of a moufang loop. I'd guess that there's one of order  6 that's the smallest one?

@WheatWizard facepalm D_3, of course. they better take away my math degree...or at least my A in Algebra :'(

@Giuseppe Don't feel too bad, I also made a mistake when correcting yours it's 12 not 11. I should have realized that because 11 is prime number.

this is A000001 + A090750

@IanGödel Ok I've added an example of showing that a particular input is a Moufang loop.  Feel free to voice any more concerns including ways to make this less "fluffy".

Python 3, 475 410 bytes
Thanks to Mr.Xcoder for saving some bytes!
Use the symmetry of the formula to save 65 bytes. Yes, that's a lot.
from itertools import*
n=int(input())
P=permutations
R=[*range(n)]
u=[]
A=all
S=sorted
for T in P(P(R),n):u+=[T]*(A(A(R==S(x)for x in
t)and any([*x]==S(x)for x in t)and
A(t[z][t[x][t[z][y]]]==t[t[t[z][x]][z]][y]and
t[t[z][x]][t[y][z]]==t[t[z][t[x][y]]][z]for x in R
for y in R for z in R)for t
in(T,[*zip(*T)]))and A(A(1-A(p[T[i][j]]==U[p[i]][p[j]]for i in R
for j in R)for p in P(R))for U in u))
print(len(u))

Try it online!

Some and can be replaced by *, results in lower bytecount but at the cost of significantly slower execution time:
Python 3, ??? bytes
[TODO put code here]
(of course not all * makes the program significantly slower, only some of them are critical)

Ungolfed:
from itertools import *
n = 4 # int(input())
rangeN = list(range(n))

def is_moufang_loop(T):
    A = tuple(zip(*T))
    return all(
        all(sorted(x) == rangeN for x in t)
        and any(list(x) == sorted(x) for x in t)
        and all(
                T[z][T[x][T[z][y]]] == T[T[T[z][x]][z]][y]
            and T[T[z][x]][T[y][z]] == T[T[z][T[x][y]]][z]
            for x in rangeN for y in rangeN for z in rangeN)
        for t in (T, A)
    )

def isomorphic(loop1, loop2):
    for p in permutations(rangeN):
        if all(
            p[loop1[i][j]] == loop2[p[i]][p[j]]
            for i in rangeN
            for j in rangeN
        ): return True
    return False

unique_moufang_loops = []
for x in [
        cayley_table
        for cayley_table in permutations(permutations(rangeN), n)
        if is_moufang_loop(cayley_table)
]:
    if all(not isomorphic(x, y) for y in unique_moufang_loops):
        unique_moufang_loops.append(x)

print(len(unique_moufang_loops))

Try it online!
No scroll bars...

Explanation:
The program is pretty simple.

Each possible "binary operator" is represented by a Cayley table (0-indexing).
The "identity" property implies that there exists e such that both the e'th row and the e'th column are equal to [0, 1, 2, ..., n-1], which is the same condition as

both the array T and its transpose has a row equal to [0, 1, 2, ..., n-1].

The "cancellation" property is equivalent to

Every row and every column are a permutation of [0, 1, 2, ..., n-1].

So, the part
all(
        all(sorted(x) == rangeN for x in t)
        and any(list(x) == sorted(x) for x in t)
        for t in (T, A))

of the code checks that. (for all row in the array T and its transpose A, it being sorted is equal to rangeN, and there exists a row in both T and A that equals to itself being sorted)
The four conditions of a Moufang loops are checked manually.
z + (x + (z + y)) = ((z + x) + z) + y
((y + z) + x) + z = y + (z + (x + z))
(z + x) + (y + z) = (z + (x + y)) + z
(z + x) + (y + z) = z + ((x + y) + z)

In the code, (a + b) is represented as T[a][b]. (because of the representation as Cayley table). Use Python chaining equality comparison to avoid duplication of (z + x) + (y + z).
However, because the formula is symmetric:
If we switch the operands of + in the first formula, we get the second formula; and if we switch the operands of + in the third formula, we get the fourth formula with x and y swapped place.
Note that the transposition of the Cayley table is equivalent to the binary operators having operands swapped. (x + y -> y + x)
Finally, all the candidates Cayley table are picked from
permutations(permutations(rangeN), n)

so that each row is a permutation of rangeN (which is [0, 1, 2, ..., n-1]) and there are n distinct rows.


text:
Compute the Optimal Square Matrix
The optimal matrix (for the rather narrow scope of this challenge) is obtained by "zipping" the elements from the corresponding rows and columns of a square matrix and getting the maximum of each pair.
For instance, given the following matrix:
4 5 6
1 7 2
7 3 0

You can combine it with its transpose to get: [[[4,5,6],[4,1,7]],[[1,7,2],[5,7,3]],[[7,3,0],[6,2,0]]]. If you zip each pair of lists, you obtain the following: [[(4,4),(5,1),(6,7)],[(1,5),(7,7),(2,3)],[(7,6),(3,2),(0,0)]]. The last step is to get the maximum of each pair to get the optimal matrix:
4 5 7
5 7 3
7 3 0

Your task is to output the optimal matrix of a square matrix given as input. The matrix will only contain integers. I/O can be done in any reasonable format. The shortest code in bytes (either in UTF-8 or in the language's custom encoding) wins!
Tests

[[172,29],[29,0]] -> [[172,29],[29,0]]
[[4,5,6],[1,7,2],[7,3,0]] -> [[4,5,7],[5,7,3],[7,3,0]]
[[1,2,3],[1,2,3],[1,2,3]] -> [[1,2,3],[2,2,3],[3,3,3]]
[[4,5,-6],[0,8,-12],[-2,2,4]] -> [[4,5,-2],[5,8,2],[-2,2,4]]

Can we output a flat version of the matrix? e.g. [1,2,3,4] instead of [[1,2],[3,4]]? Would save ~33%

Jelly, 2 bytes
»Z

Try it online!
How it works
»Z  Main link. Argument: M (integer matrix)

 Z  Zip the rows of M, transposing rows and columns.
»   Take the maxima of all corresponding integers.

Oh my... Why in the world does » behave like that?!

Pretty standard for an array manipulation language. Octave's max does the same.

Husk, 5 4 bytes
Whoop, never got to use ‡ before (or †):
S‡▲T

Try it online!
Explanation
S  T -- apply the function to itself and itself transposed
 ‡▲  -- bi-vectorized maximum

Haskell, 40 bytes
z(z max)<*>foldr(z(:))e
e=[]:e
z=zipWith

Try it online!
I would ungolf this as:
import Data.List
f m = zipWith (zipWith max) m (transpose m)

...which is so much more elegant.

I find it funny that the best I could golf in Clean is identical to your ungolfed Haskell.

Octave, 13 bytes
@(A)max(A,A')

Try it online!

MATL, 6 bytes
t!2$X>

Try it online!
Explanation:
t        % Duplicate the input.
!        % Transpose the duplicate.
2$X>     % Elementwise maximum of the two matrices.

Also 6 bytes: _t!Xl_ and tt!&Xl.

APL (Dyalog Unicode), 3 bytes
Anonymous tacit prefix function.
⊢⌈⍉

Try it online!
⊢ argument
⌈ ceiling'd with
⍉ transposed argument

J, 4 bytes
Tacit prefix function.
>.|:

Try it online!
>. ceiling [of the argument] with
|: the transposed argument

Um, I don't think you need to include f=:. :P at first I thought you reduced the bytecount by 3 bytes...

<. is supposed to be >.

@FrownyFrog Indeed.

@EriktheOutgolfer No, I don't.

JavaScript (ES6), 48 bytes
m=>m.map((r,y)=>r.map((v,x)=>v>(k=m[x][y])?v:k))

Test cases

let f =

m=>m.map((r,y)=>r.map((v,x)=>v>(k=m[x][y])?v:k))

console.log(JSON.stringify(f([[172,29],[29,0]]            ))) // -> [[172,29],[29,0]]
console.log(JSON.stringify(f([[4,5,6],[1,7,2],[7,3,0]]    ))) // -> [[4,5,7],[5,7,3],[7,3,0]]
console.log(JSON.stringify(f([[1,2,3],[1,2,3],[1,2,3]]    ))) // -> [[1,2,3],[2,2,3],[3,3,3]]
console.log(JSON.stringify(f([[4,5,-6],[0,8,-12],[-2,2,4]]))) // -> [[4,5,-2],[5,8,2],[-2,2,4]]

Japt, 12 10 8 bytes
Look, Ma, no transposing or zipping!
£XËwUgEY

Try it

CJam, 8 bytes
{_z..e>}

Anonymous block (function) that takes the input from the stack and replaces it by the output.
Try it online! Or verify all test cases.
Explanation
{      }    e# Define block
 _          e# Duplicate
  z         e# Zip
   .        e# Apply next operator to the two arrays, item by item
            e# (that is, to rows of the two matrices)
    .       e# Apply next operator to the two arrays, item by item
            e# (that is, to numbers of the two rows)
     e>     e# Maximum of two numbers

C (gcc), 79 77 bytes

Saved two bytes thanks to Steadybox; only taking in one matrix dimension parameter as all matrices in this challenge are square.

j,i;f(A,n)int*A;{for(j=0;j<n*n;j++)printf("%d,",A[A[j]>A[i=j/n+j%n*n]?j:i]);}

Try it online!
Takes a flat integer array A and the matrix dimension n (as the matrix has to be square) as input. Outputs a flat integer array string representation to stdout.

Clean, 58 bytes
import StdEnv,StdLib
@l=zipWith(zipWith max)(transpose l)l

I don't think this needs an explanation.
Try it online!

Wolfram Language (Mathematica), 23 bytes
A port of my Pari/GP answer.
(#+#+Abs[#-#])/2&

 is \[Transpose].
Try it online!

Julia 0.6, 13 bytes
max. applies the function max elementwise to it's arugments.

a->max.(a,a')

Try it online!

R, 23 bytes
function(A)pmax(A,t(A))

Try it online!
This is equivalent to most other answers. However, R has two distinct max functions for the two common scenarios:

max and min return the maximum or minimum of all the values present in their arguments, as integer if all are logical or integer, as double if all are numeric, and character otherwise.
pmax and pmin take one or more vectors (or matrices) as arguments and return a single vector giving the ‘parallel’ maxima (or minima) of the vectors. The first element of the result is the maximum (minimum) of the first elements of all the arguments, the second element of the result is the maximum (minimum) of the second elements of all the arguments and so on. Shorter inputs (of non-zero length) are recycled if necessary.

Mathematica, 30 bytes
-8 bytes thanks to Jonathan Frech.
Map@Max/@t/@t@{#,t@#}&
t=#&

Try it online!

40 bytes; using Mathematica's transpose operator.

How would you implement this in an Mathematica notebook using, say, the 2nd test case ({{4,5,6},{1,7,2},{7,3,0}})?

Pari/GP, 21 bytes
m->(m+m~+abs(m-m~))/2

Try it online!

Python 2, 45 bytes
lambda k:[map(max,*c)for c in zip(k,zip(*k))]

Try it online!
Thanks to totallyhuman for a few bytes saved.

45 bytes.

05AB1E, 7 bytes
ø‚øεøεà

Try it online!
Explanation
ø         # transpose input matrix
 ‚        # pair with original matrix
  ø       # zip together
   ε      # apply on each sublist ([[row],[transposed row]])
    ø     # zip
     ε    # apply on each sublist (pair of elements)
      à   # extract greatest element

Jelly, 7 bytes
żZZṀ€$€

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Factor-poor numbers
If a positive integer \$N > 2\$ has (strictly) less prime factors (without counting multiplicities) than its successor and its predecessor, we will call it a factor-poor number.
In other words, \$\omega(N) < \omega(N - 1)\$ and \$\omega(N) < \omega(N + 1)\$, where \$\omega(N)\$ is the number of unique prime factors of \$N\$.
Task
You can choose among the following I / O formats:

Take an integer \$N\$ and output the \$N^{\text{th}}\$ factor-poor number. In case you choose this one, \$N\$  can either be 0 or 1 indexed.
Take a positive integer \$N\$ and output the first \$N\$ factor-poor numbers.
Print the sequence indefinitely.

You can take input and provide output through any standard method, in any programming language, while taking note that these loopholes are forbidden by default. This is code golf, so the shortest submission that abides to the rules wins.
I won't include separate test cases, because the methods of competing are different, but you can refer to the first 100 terms of this sequence, which is OEIS A101934:
11, 13, 19, 23, 25, 27, 29, 37, 41, 43, 47, 49, 53, 59, 61, 64, 67, 71, 73, 79, 81, 83, 89, 97, 101, 103, 107, 109, 113, 121, 125, 131, 137, 139, 149, 151, 155, 157, 163, 167, 169, 173, 179, 181, 191, 193, 197, 199, 211, 221, 223, 227, 229, 233, 239, 241, 243, 251, 259, 263, 265, 269, 271, 277, 281, 283, 289, 293, 307, 309, 311, 313, 317, 331, 337, 341, 343, 347, 349, 353, 359, 361, 365, 367, 371, 373, 379, 383, 389, 397, 401, 407, 409, 419, 421, 431, 433, 439, 441, 443

As an example, \$25\$ occurs in this sequence because \$\omega(25) = 1\$ (5), \$\omega(26) = 2\$ (2 and 13) and \$\omega(24) = 2\$ (2 and 3), so \$\omega(25) < \omega(24)\$ and \$\omega(25) < \omega(26)\$.

Can I output a leading n =  before each value?

@Steadybox Sketchy, but I'll allow it :-/

I added it as an alternative version.

Brachylog, 21 bytes
⟨+₁≡-₁⟩{ḋdl}ᵐ⌋>~↰₂?ẉ⊥

Try it online!
Prints infinitely.
Explanation
⟨+₁≡-₁⟩                  Fork: The output of the fork is [Input + 1, Input -1]
       {   }ᵐ            Map:
        ḋdl                (predicate 2) the output is the length of the prime decomposition
                           of the input with no duplicates
             ⌋           Take the minimum result of that map
              >          This minimum is bigger than…
               ~↰₂?      …the output of predicate 2 with Input as input
                  ?ẉ     Write Input followed by a new line if that's the case
                    ⊥    False: backtrack and try another value for Input

Jelly, 13 12 bytes
Cr~ÆvÐṂN⁼Wø#

Prints the first n factor-poor numbers.
Try it online!
How it works
Cr~ÆvÐṂN⁼Wø#  Main link. No arguments.

          ø   Wrap the links to the left into a chain and begin a new chain.
           #  Read an integer n from STDIN and call the chain to the left with
              arguments k = 0, 1, 2, ... until n of them return a truthy value.
              Return those n values of k as an array.
C                 Complement; yield -k+1.
  ~               Bitwise NOT; yield -k-1.
 r                Range; yield [-k+1, -k, -k-1].
     ÐṂ           Yield those elements of [-k+1, -k, -k-1] for which the link to
                  the left returns the minimal value.
   Æv                 Count the number of unique prime factors.
                      Note that, for a negative argument, Æv counts -1 as well, and
                      0 is counted as a/the factor of 0. Negating the the arguments
                      eliminates the edge case 1 (no factors), which would be a
                      false positive otherwise.
                  For a factor-poor number, this yields [-k].
       N          Take the negatives of the resulting integers.
         W        Wrap; yield [k].
        ⁼         Test the results to both sides for equality.

Python 2, 123 119 bytes
q=lambda n:sum(n%i<all(i%j for j in range(2,i))for i in range(2,n+1))
i=2
while 1:
 i+=1
 if q(i-1)>q(i)<q(i+1):print i

Try it online!

@FryAmTheEggman thanks! Even that I didn't used your suggestion, it inspired me on another approach that saved 4 bytes :D

Nice! I was sure there was a way to avoid two ugly lambdas :)

MATL, 26 24 22 bytes
`T@3:q+YFg!sdZSd0>?@QD

Prints the sequence indefinitely.
Try it online!
Explanation
`         % Do...while loop
  T       %   Push true. Will be used as loop condition
  @       %   Push (1-based) iteration index, k
  3:q     %   Push [1 2 3] minus 1, that is, [0 1 2]
  +       %   Add, element-wise. Gives [k k+1 k+2]
  YF      %   Exponents of prime-factor decomposition. Gives a 3-row matrix
  g       %   Convert to logical: non-zero numbers become 1
  !s      %   Transpose, sum of each column. Gives a row vector of 3 elements,
          %   which are the number of unique prime factors of k, k+1 and k+2
  d       %   Consecutive differences. Gives a row vector of 2 elements
  ZS      %   Sign: replaces each number by -1, 0 or 1
  d       %   Consecutive difference. Gives a single number
  0>      %   Is it positive?
  ?       %   If so
    @Q    %     Push k+1
    D     %     Display
          %   End (implicit)
          % End (implicit). The stack contains true, which (is consumed and)
          % causes an infinite loop

Pyth, 14 bytes
.f!-.ml{Pb}tZh

Try it here!
It was initially a suggestion on Dopapp's answer, but they told me to post it separately.
How it works?

.f!-.ml{Pb}tZh | Full program. Takes input from STDIN, outputs the first N to STDOUT.

.f             | (var: Z) Output the first N values which satisfy the predicate.
          }tZh | Creates the list [Z - 1, Z, Z + 1].
    .m         | (var: b) Take the elements with minimal function value.
        Pb     | Prime factors of b.
      l{       | Deduplicate, get length.
               | For a factor-poor number, this yields itself wrapped in a singleton.
   -           | Remove Z from that.
  !            | Logical negation.

Haskell, 105 86 bytes
Thanks to @Wheat Wizard, @Bruce Forte, and @Laikoni for saving 19 bytes.
[n|n<-[2..],d n<d(n-1),d n<d(n+1)]
d x=[1|n<-[1..x],x`rem`n<1,all((>0).rem n)[2..n-1]]

when using rem ==0 and /=0 can be relaced with <1 and >0 respectively.

There is no need for a let, defining d as auxiliary function is fine (see the guide to golfing rules). Also sum can be omitted, the comparison works the same on lists. 86 bytes: Try it online!

Husk, 22 bytes
f(ΠtSM<←ṙ1mȯLup§…←→)tN

Prints the sequence indefinitely, try it online or view the first N!
Alternatively §oΛ>←t could be used instead of ΠtSM<←.
Explanation
f(                  )tN  -- filter the tail of the naturals ([2,3…]) by:
  ΠtSM<←ṙ1m(Lup)§…←→     -- | takes a number as argument, example 11
                §…       -- | range of..
                  ←      -- | | the argument decremented (10)
                   →     -- | | to the argument incremented (12)
                         -- | : [10,11,12]
          m(   )         -- | map the following (example on 12) ..
              p          -- | | prime factors: [2,2,3]
             u           -- | | deduplicate: [2,3]
            L            -- | | length: 2
                         -- | : [2,1,2]
        ṙ1               -- | rotate by 1: [1,2,2]
    SM<                  -- | map the function (< X) over the list where X is ..
       ←                 -- | | the first element (1)
                         -- | : [0,1,1]
   t                     -- | tail: [1,1]
  Π                      -- | product: 1
                         -- : [11,13,19,23,25,27,29…

05AB1E, 14 13 bytes
Outputs the nth factor-poor number (1-indexed)
µ3LN+Íf€gÀć›P

Try it online!
Explanation
µ                 # loop over N (1,2,3, ...) until counter equals input
 3L               # push the range [1,2,3]
   N+             # add current N
     Í            # subtract 2
      f           # get unique prime factors of each
       €g         # get length of each factor list
         À        # rotate left
          ć       # extract the head
           ›      # check if the remaining elements are strictly greater
            P     # product
                  # if 1, increment counter
                  # implicitly output final N

I was just about t suggest switching to µ, so I guess I am just going to point out my alternative – N<N>Ÿ can substitute 3LN+Í, if that helps.

@Mr.Xcoder: Similarily, ®XŸN+ also works. Or 0®X)N+ in which case À would not be needed. Unfortunately they all end up at the same byte count.

Octave,  87   83  79 bytes
Thanks to @Cows quack for saving a byte and thanks to @Luis Mendo for saving three six bytes!
f=@(n)nnz(unique(factor(n)));n=9;while++n if[f(n-1) f(n+1)]>f(n)disp(n);end;end

Prints the sequence indefinitely.
Try it online!
73 bytes with leading n = before each value:
f=@(n)nnz(unique(factor(n)));n=9;while++n if[f(n-1) f(n+1)]>f(n)n end;end

Try it online!

I think the function f can become f=@(n)length(unique(factor(n))) for one less byte.

Pyth, 30 25 bytes
#=hTI&>l{PhTKl{PT>l{PtTKT

This is my first real Pyth golf, so any comments are very appreciated.
A big thanks to Xcoder!
Explanation
#                         | Loop until error
 =hT                      | Add one to T (initially 10)
    I&                    | If both...
      >l{PhTKl{PT         | The number of unique prime factors of T+1 is greater than that of T (store in K)
                 >l{PtTK  | And the number of unique prime factors of T-1 is greater than K (from before)
                        T | Then implicitly print T

TIO.

14 bytes: .f!-.ml{Pb}tZh (prints the first n) (.f retrieves the first n values that satisfy a condition over [1,2,3,...] and uses a variable Z, }tZh generates the integer range [Z - 1 ... Z + 1], .m return the list of elements with minimal function value (with b), l{Pb gets the count of distinct divisors, - discards Z from the list, ! applies logical negation)

@Mr.Xcoder, wow I don't think I would have gotten that anytime soon! Wouldn't you say it merits its own answer?

@Dopapp Ok then, I posted it separately. +1 Welcome to Pyth golfing!

25 bytes using your approach.

Nope. h is +1, t is -1, while K is a variable which gets assigned without =. For example, K4 assigns K to 4. You can then access it using K.

@Mr.Xcoder, ah so Kl{PT both assigns l{PT to K and returns the newly assigned K?

Precisely. Now you can reuse without assigning it separately.

JavaScript (ES6), 94 bytes
Returns the Nth factor-poor number, 0-indexed.
f=(i,n=9)=>(P=(n,i=k=1)=>++k>n?0:n%k?P(n,1):i+P(n/k--,0))(n)>P(++n)&P(n)<P(n+1)&&!i--?n:f(i,n)

Try it online!
How?
We first define the P() function which returns the number of unique prime factors of a given integer.
P = (                   // P = recursive function taking:
  n,                    //   n = input number to test
  i =                   //   i = flag to increment the number of prime factors
  k = 1                 //   k = current divisor
) =>                    //
  ++k > n ?             // increment k; if k is greater than n:
    0                   //   stop recursion
  :                     // else:
    n % k ?             //   if k is not a divisor of n:
      P(n, 1)           //     do a recursive call with n unchanged and i = 1
    :                   //   else:
      i +               //     add i and
      P(n / k--, 0)     //     do a recursive call with n / k and i = 0; decrement k

The wrapping code now reads as:
f = (                   // given:
  i,                    //   i = input index
  n = 9                 //   n = counter
) =>                    //
  P(n) > P(++n) &       // increment n; if P(n - 1) is greater than P(n)
  P(n) < P(n + 1) &&    // and P(n) is less than P(n + 1)
  !i-- ?                // and we have reached the correct index:
    n                   //   return n
  :                     // else:
    f(i, n)             //   go on with the next value

Japt, 29 27 26 bytes
Not entirely happy with this but at least it's better than my first attempt which was over 40 bytes!
Outputs the Nth number in the sequence, 1-indexed.
È=Jõ_+X k â ÊÃé)e>Xo)«´U}a

Try it

Explanation
Implicit input of integer U.
È                       }a

Return the first integer X that returns true when passed through the following function.
=Jõ             )

Assign the array [-1,0,1] to X.
 _+X      Ã

Pass each element of that array through a function which firstly adds the current value of X.
k â Ê

Get the length (Ê) of the unique (â) prime factors (k) of the result.
é

Rotate the resulting array one to the right.
e>Xo)

Pop (o) the last element from X and check if all remaining elements are greater than it.
«´U

If so, decrement U and check if it is equal to 0.

Python 3, 97 bytes
n,g=9,lambda m,k=2,p=1:m//k and(m%k<p%k)+g(m,k+1,p*k*k)
while 1:n+=1;g(n-1)>g(n)<g(n+1)!=print(n)

In theory, this prints the sequence indefinitely. In practice, g eventually exceeds the recursion limit.
Try it online!

C (gcc), 126 bytes
j,t;o(n){for(j=t=0;j++<n;)if(n%j<1)for(t--;j>1>n%j;)n/=j;t=~t;}
m(J){for(J=3;;J++)if(o(J-1)>o(J)&o(J)<o(J+1))printf("%d,",J);}

Try it online!

APL NARS, 124 bytes, 62 chars
{(⍵>1E4)∨⍵≤0:¯1⋄x←9+⍳10×⍵⋄⍵↑(∊{v←⍴∘∪∘π¨⍵+2-⍳3⋄2=+/v>2⌷v}¨x)/x}

It should return answer until 1E4, then return -1 error; it suppose 9..10xargument
has enought right numbers; test:
  z←{(⍵>1E4)∨⍵≤0:¯1⋄x←9+⍳10×⍵⋄⍵↑(∊{v←⍴∘∪∘π¨⍵+2-⍳3⋄2=+/v>2⌷v}¨x)/x}
  z 0
¯1
  z 1
11
  z 20
11 13 19 23 25 27 29 37 41 43 47 49 53 59 61 64 67 71 73 79

about 150 bytes?

@Shaggy yes it was one approximate value; but +- it is right for the golfed one...

By my count the score here is 147 bytes, not 152 (number of characters is irrelevant). Further reading: https://codegolf.meta.stackexchange.com/q/9428/58974

@Shaggy the number 152 would be the size in bytes of one file that contain only that code (copy past, save that code in a notepad (Window) document and observe "property " of that file )

That's not how we count bytes here.

@Shaggy so how I have to count bytes? Possibly save a .txt file with notepad, and count its size with a C program?

Clean, 130 123 117 bytes
import StdEnv
?n=[1\\q<-[p\\p<-[2..n]|and[gcd p i<2\\i<-[2..p-1]]]|n rem q<1]
f=[n\\n<-[3..]| ?n<min(?(n-1))(?(n+1))]

Equates to an infinite number of terms of the sequence. Since it's all nested comprehensions, it can't take advantage of graph reduction very well and so is quite slow, even for such a bad algorithm.
Try it online!

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Find the largest number of distinct integers that sum to n
The Task
Given an input positive integer n (from 1 to your language's limit, inclusively), return or output the maximum number of distinct positive integers that sum to n.
Test Cases
Let f define a valid function according to the task:
The sequence for f, starting at 1:
1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, ...

As a larger test case:
>>> f(1000000000) // Might not be feasible with brute-forcers
44720

Test Code
For any test cases not explicitly given, the output of your code should match the result of the following:
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        System.out.println((int) Math.floor(Math.sqrt(2*x + 1./4) - 1./2));
    }
}

Try it online!

Can it be 0-indexed?

@totallyhuman "it" being the answers? Because this isn't about a list...

Yes. Can the output for 1 be 2?

@totallyhuman No. This is about the distinct partitions of specific numbers.

This is OEIS A003056.

If it helps anyone, this is equivalent to finding the last triangle number, and returning its index in the sequence of triangle numbers.

I feel insignificant most every time I stumble into the codegolf stack.  The answers and the comments are much more than humbling.  The questions are usually interesting too but with his comment @JeppeStigNielsen just throws in the completed blueprints when we are still contemplating the floor area.

05AB1E, 4 bytes
ÅTg<

Try it online!
Perfect tool for the job.
ÅT yields the list of Åll Triangular numbers up to and including N (unfortunately includes 0 too, otherwise it would be 3 bytes), g< gets the length and decrements it.

Jelly, 6 5 bytes
R+\»ċ

Try it online!
Somewhat efficient. This sequence increments at triangular numbers, so this just counts how many triangular numbers are smaller than n.
Explanation:
        # Main link
R       # Range, generate [1..n]
 +\     # Cumulative sum (returns the first n triangular numbers)
   »    # For each element, return the maximum of that element and 'n'
    ċ   # How many elements are 'n'? (implicit right argument is n)

In the explanation, you surely mean "how many numbers are smaller than or equal to n"

@LuisMendo See the new explanation.

Haskell, 26 bytes
-2 bytes thanks to H.PWiz.
(!!)$do x<-[0..];x<$[0..x]

Try it online!
This returns the nth element of the whole numbers where each i is replicated i + 1 times.

I can't help but ask what "succ" is

Yeah, I know lol. succ stands for successor.

Brain-Flak, 36 bytes
<>(())({()<(({}())){<>({}[()])}>{}})

Try it online!
This uses the same structure as the standard division algorithm, except that the "divisor" is incremented every time it is read.

Pari/GP, 19 bytes
n->((8*n+1)^.5-1)\2

Try it online!

Jelly, 7 bytes
×8‘½’:2

Try it online!
Jelly, 9 bytes
Ḥ+4İ¤½_.Ḟ

Try it online!
This is longer than Dennis’ and DJ’s, but this time on purpose. Very, very efficient.

lol I love precision

@totallyhuman Use M.

Brain-Flak, 82 bytes
Whitespace added for "Readability"
(())

{
    {}

    ((({})[[]]))

    ([({}<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}

}{}{}{}

([]<>)

Try it online!

Competition as always

Who'd've thought that combining two unreadable languages, Whitespace and Brain-Flak, could be considered "readable"!

R, 28 bytes
function(n)rep(1:n,1:n+1)[n]

Try it online!
Creates the vector of 1 repeated 2 times, 2 repeated 3 times, ..., n repeated n+1 times and takes the nth element. This will memory error either because 1:n is too large or because the repeated list with n*(n+1)/2 - 1 elements is too large.
R, 29 bytes
function(n)((8*n+1)^.5-1)%/%2

Try it online!
Computes the value directly, using the formula found in alephalpha's answer. This should run with no issues, apart from possibly numerical precision.
R, 30 bytes
function(n)sum(cumsum(1:n)<=n)

Try it online!
Counts the triangular numbers less than or equal to n. This'll possibly memory error if 1:n is large enough -- for instance, at 1e9 it throws Error: cannot allocate vector of size 3.7 Gb.

Pyth, 7 bytes
lh{I#./

Try it online!
Filter-keep the integer partitions which are Invariant over deduplication, grab the head and obtain its length.
Validity proof
Not very rigorous nor well-worded.
Let A = a1 + a2 + ... + an and B = b1 + b2 + ... + bm be two distinct partitions of the same integer N. We will assume that A is the longest unique partition. After we deduplicate B, that is, replace multiple occurrences of the same integer with only one of them, we know that the sum of B is less than N. But we also know that the function result is increasing (non-strictly), so we can deduce that the longest unique partition  A always has at least the same amount of elements as the count of unique items in other partitions.

APL (Dyalog), 8 bytes
+/+\∘⍳<⊢

Try it online!

Japt, 8 bytes
Closed formula solution.
*8Ä ¬É z

Try it

Explanation
Multiply by 8, add 1 (Ä), get the square root (¬), subtract 1 (É) and floor divide the result by 2 (z).

Alternative, 8 bytes
Port of DJMcMayhem's Jelly solution.
õ å+ è§U

Try it
Generate an array of integers (õ) from 1 to input, cumulatively reduce (å) by addition (+) and count (è) the elements that are less than or equal to (§) the input (U).

Befunge, 32 20 bytes
1+::1+*2/&#@0#.-`#1_

Try it online!

TI-Basic, 12 bytes
int(√(2Ans+1/4)-.5

JavaScript (Node.js), 18 bytes
x=>(x-~x)**.5-.5|0

Try it online!

Is this always correct? I'm not certain floor((sqrt(8x+4)-1)/2) (your formula) and floor((sqrt(8x+1)-1)/2) (correct formula) give the same result for every x.

@ETHproductions I could bluff and say "yes", but I think the more honest answer is that you should try to develop your own hypothesis and figure out if / why it mirrors the same formula. I didn't come up with this approach by myself (I learned it from a different site) but I played around with it a bit. It's a very interesting approach and I don't want to dissect the frog so early.

Hmm. I'm not sure how to prove it directly, but I wrote a brute-forcer that does not find any failures under 100 million.

Java (JDK), 28 bytes
n->~-(int)Math.sqrt(8*n+1)/2

Try it online!
Because the example was really not well golfed :p
Credits

-2 bytes thanks to Kevin Cruijssen

28 bytes "Because your code was really not well golfed" ;p

@KevinCruijssen Well, now it is! :o

Brain-Flak, 70 56 48 bytes
{([(({}[({}())()])[()])]<>){<>({}())}{}<>{}}<>{}

Try it online!
Explanation
The main part of this is the following snippet that I've written:
([(({})[()])]<>){<>({}())}{}<>{}

This will do nothing if the TOS is positive and will switch stacks otherwise.  It is super stack unclean but it works.  Now the main part of the program subtracts increasingly large numbers from the input until the input is non-positive.  We start the accumulator at 1 each time subtracting 1 more than the accumulator from the input.
({}[({}())()])

We can put that inside the snippet above
([(({}[({}())()])[()])]<>){<>({}())}{}<>{}

That is put in a loop so it executes until we switch stacks.  Once the loop finishes we retrieve the accumulator by switching stacks and removing the junk.

Some more competition

Triangularity, 49 bytes
....)....
...2)2...
..)1/)8..
.)1/)IE/.
@^)1_+/i.

Try it online!
How it works
Triangularity requires the code to have a triangular distribution of the dots. That is, the length of each row must be equal the number of rows multiplied by 2 and decremented, and each row must have (on each side) a number of dots equal to its position in the program (the bottom row is row 0, the one above it is row 1 and so forth). There are only a couple of commands, and any character other than those listed on the 'Wiki / Commands' page is treated as a no-op (extraneous dots don't make affect the program in any way, as long as the overall shape of the program stays rectangular).
Note that for two-argument commands, I've used a and b throughout the explanation. Keeping that in mind, let's see what the actual program does, after removing all the extraneous characters that make up for the padding:
)2)2)1/)8)1/)IE/@^)1_+/i | Input from STDIN and output to STDOUT.

)                        | Push a 0 onto the stack. Must precede integer literals.
 2                       | Push ToS * 10 + 2 (the literal 2, basically).
  )2                     | Again, push a 2 onto the stack. This can be replaced by D
                         | (duplicate), but then the padding would discard the saving.
    )1                   | Literal 1.
      /                  | Division. Push b / a (1 / 2).
       )8)1              | The literal 8 and the literal 1 (lots of these!).
           /             | Division. Push b / a (1 / 8).
            )IE          | Get the 0th input from STDIN and evaluate it.
               /         | Divide it by 1 / 8 (multiply by 8, but there isn't any
                         | operand for multiplication, and I'm not willing to add one).
                @        | Add 1 to the result.
                 ^       | Exponentiation. Here, it serves as a square too.
                  )1_+   | Decrement (add literal -1).
                      /  | Divide (by 2).
                       i | Cast to an integer.

An alternate solution, and shorter if padding would not be necessary:
....)....
...2)1...
../DD)I..
.E/)4)1/.
+^s_+i...

Try it online!

PowerShell 3.0, 45 bytes
[math]::Sqrt(2*$args[0]+.25)-.5-replace'\..*'

The math call hurt and PS's banker's rounding is the actual devil (hence needing regex to truncate to save a byte) but this seems pretty alright.

Jelly, 7 bytes
ŒPfŒṗṪL

Runs roughly in O(2n) time.
Try it online!
How it works
ŒPfŒṗṪL  Main link. Argument: n

ŒP       Powerset; yield all subarrays of [1, ..., n], sorted by length.
   Œṗ    Yield all integer partitions of n.
  f      Filter; keep subarrays that are partitions.
     Ṫ   Tail; extract the last result.
      L  Compute its length.

JavaScript (ES7), 22 19 bytes
n=>(8*n+1)**.5-1>>1

-3 bytes thank to ETHproductions.

Try it

o.innerText=(f=
n=>(8*n+1)**.5-1>>1
)(i.value=1000000000);oninput=_=>o.innerText=f(+i.value)
<input id=i type=number><pre id=o>

Explanation
Multiply the input by 8 and add 1, raise that to the power of .5, giving us the square root, subtract 1 and bitshift the result right by 1.

Can you include an explanation? I haven't done Javascript in a while

How bout n=>(8*n+1)**.5-1>>1 to save 3 bytes? (haven't tested)

I outgolfed this in JS: https://codegolf.stackexchange.com/a/152558/21830

@ETHproductions - looks like that works, thanks.

@tfbninja, I'd have thought t fairly self-explanatory but explanation added.

Haskell, 28 bytes
Kinda boring, but it's quite shorter than the other Haskell solution and has a really nice pointfree expression. Unfortunately I couldn't get it any shorter without the type system getting in the way:
g x=floor$sqrt(2*x+0.25)-0.5

Try it online!
Pointfree, 33 bytes
ceiling.(-0.5+).sqrt.(0.25+).(2*)

Alternatively, 33 bytes
Same length as the pointfree version, but much more interesting.
g n=sum[1|x<-scanl1(+)[1..n],n>x]

I managed to tie the formula by fixing some dumb mistakes!

@totallyhuman: Nice, now yours is much nicer too :)

Python 2/3, 32 bytes
Python implementation of the closed form formula
lambda n:int((sqrt(1+8*n)-1)//2)

The integer division //2 rounds towards zero, so no floor( ) required

Welcome to PPCG! Does this need from math import sqrt to work? If so, it should be included in the bytecount. (In that case lambda n:int((math.sqrt(1+8*n)-1)//2) import math is a little shorter.)

29 bytes

Yes, it needs the import to work, so that should be included in the byte count.

Milky Way, 12 bytes
'8*1+g1-2/v!

Explanation
code         explanation       value

'            push input        n
 8*          push 8, multiply  8n
   1+        add 1             8n+1
     g       square root       sqrt(8n+1)
      1-     subtract 1        sqrt(8n+1)-1
        2/   divide by 2       (sqrt(8n+1)-1)/2
          v  floor             floor((sqrt(8n+1)-1)/2)
           ! output

Pyt, 7 5 bytes
Đř△>Ʃ

Explanation:
                      Implicit input
Đř△                   Gets a list of the first N triangle numbers
   >                  Is N greater than each element in the list? (returns an array of True/False)
    Ʃ                 Sums the list (autoconverts booleans to ints)

Faster, but longer way
Pyt, 11 9 bytes
Đ2*√⌈ř△>Ʃ

Explanation:
Đ2*√⌈ř△           Gets a list of triangle numbers up to the ceiling(sqrt(2*N))-th
       >          Is N greater than each element of the list? (returns an array of True/False)
        Ʃ         Sums the array

Alternative way - port of Shaggy's answer
Pyt, 8 7 bytes
8*⁺√⁻2÷

J, 11 bytes
2&!inv<.@-*

Try it online!
2&!inv       solve [x choose 2 = input]
         -*  minus 1
      <.     and floor

I like that trick with * to produce 1

Whitespace, 111 bytes
[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_integer_from_STDIN][T T   T   _Retrieve_input][S S S T    S S S N
_Push_8][T  S S N
_Multiply][S S S T  N
_Push_1][T  S S S _Add][S S T   T   N
_Push_n=-1][N
S S N
_Create_Label_SQRT_LOOP][S S S T    N
_Push_1][T  S S S _Add][S N
S _Duplicate_n][S N
S _Duplicate_n][T   S S N
Multiply][S T   S S T   S N
_Copy_0-based_2nd_(the_input)][S S S T  N
_Push_1][T  S S S _Add][T   S S T   _Subtract][N
T   T   N
_If_negative_jump_to_Label_SQRT_LOOP][S S S T   S N
_Push_2][T  S S T   _Subtract][S S S T  S N
_Push_2][T  S T S _Integer_divide][T    N
S T _Print_integer]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs, and new-lines only).
Explanation in pseudo-code:
Uses the formula:
$$f_n = \left\lfloor\frac{\sqrt{8n + 1} - 1}{2}\right\rfloor$$
NOTE: Whitespace doesn't have a square-root builtin, so we have to do this manually.
Integer i = read STDIN as integer
i = i * 8 + 1
Integer n = -1
Start SQRT_LOOP:
  n = n + 1
  If(n*n < i+1):
    Go to next iteration of SQRT_LOOP
n = (n - 2) integer-divided by 2
Print n as integer to STDOUT

Vitsy, 16 bytes
2*14/+12/^12/-_N

Try it online!
Might as well add my own contribution to the mix. This is shorter than the partition iterations solution in Vitsy.

Oasis, 14 bytes
n8*1+1tm1%_b+0

Try it online!
How?
n8*1+           8n + 1
     1tm        sqrt
        1%_     integer?
           b+   add f(n-1)

             0  f(0) is 0

This is a recursive solution that increments the result when it encounters a triangular index, starting with 0 for the input 0.

Perl 5 -p, 19(++) bytes
$_=0|-.5+sqrt$_*2+1

Try it online!

Ruby, 27 bytes
Three for the price of one. I am disappointed that I can't go shorter.
->n{a=0;n-=a+=1while n>a;a}

->n{((8*n+1)**0.5-1).div 2}

->n{((n-~n)**0.5-0.5).to_i}

Try it online! (to select the function, add f= in front of it)

Pyke, 6 bytes
8*h,te

Try it here!
8      - Push literal 8.
 *     - Multiply by the input.
  h    - Increment.
   ,   - Square root.
    t  - Decrement.
     e - Floor halve.

Swift, 41 bytes
import Foundation
{Int(sqrt($0*8+1)-1)/2}

Try it online!

Pushy, 8 bytes
8*hrt2/#

Try it online!
Uses the closed formula (sqrt(8n + 1) - 1) / 2:
8*          \ Multiply by 8
  h         \ Increment
   r        \ Integer root
    t       \ Decrement
     2/     \ Floordiv by 2
       #    \ Output

I thought I recognised this formula - it's the reverse of the function for a triangle number:
f(x) = (x + 1)(x / 2)
f-1(x) = (sqrt(8x+ 1) - 1) / 2

...which makes sense as we're counting integer sums.

Add++, 12 bytes
L,ßR¬+A€<€!s

Try it online!
Because closed form solutions are boring

Wolfram Language (Mathematica), 22 bytes
⌊√(1+8*#)/2-.5⌋&

Try it online!

c++,61
int f(int n){for(int i=1;;i){if(n<i) return i-1; else n-=i}}

Consider adding a short explanation of your code (see the other answers for examples). Code-only answers like this tend to get flagged automatically as low quality.

Cubix, 16 bytes
.(@sI1-?s.O@s)W\

Try it online!
    . (
    @ s
I 1 - ? s . O @
s ) W \ . . . .
    . .
    . .

Watch it run

I1 set up the stack with n and 1 (incrementer)
-? subtract the incrementer from n and test result

if result 0 sO@, swap result with incrementer, output and halt
if result negative s(O, swap result with incrementer, decrement, output and via a few commands, halt
if result positive \s)W, redirect, swap result with incrementer, increment and redirect back into the subtract/test


text:
Print the alphabet Christmas tree
I know it's 1.5 weeks after Christmas but trying to print an isosceles triangle in a monospaced font makes it look weird.
Challenge
Print the alphabet from A to Z so that it forms a filled triangle in the output.
For each line in the output, starting from "A", add the next letter.
No inputs, only outputs. Pad the leading edge of the triangle with spaces.
Best answer is the code with the least bytes.
Output
            A
            AB
           ABC
           ABCD
          ABCDE
          ABCDEF
         ABCDEFG
         ABCDEFGH
        ABCDEFGHI
        ABCDEFGHIJ
       ABCDEFGHIJK
       ABCDEFGHIJKL
      ABCDEFGHIJKLM
      ABCDEFGHIJKLMN
     ABCDEFGHIJKLMNO
     ABCDEFGHIJKLMNOP
    ABCDEFGHIJKLMNOPQ
    ABCDEFGHIJKLMNOPQR
   ABCDEFGHIJKLMNOPQRS
   ABCDEFGHIJKLMNOPQRST
  ABCDEFGHIJKLMNOPQRSTU
  ABCDEFGHIJKLMNOPQRSTUV
 ABCDEFGHIJKLMNOPQRSTUVW
 ABCDEFGHIJKLMNOPQRSTUVWX
ABCDEFGHIJKLMNOPQRSTUVWXY
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Sample Java Code (430 bytes)
public static void main(String args[]) {
    String spaces = "";
    String alpha = "";
    char A = 'A';

    for (int i = 0; i < 26; i++) {
        for (int j = 13 - (i/2); j > 0; j--) {
           spaces += " ";
        }

        alpha += (char)(A + i);

        System.out.println(spaces + alpha);
        spaces = "";
    }
}

Welcome to PPCG and nice first challenge! Another tag that is appropriate is kolmogorov-complexity. And most likely someone will ask if leading and trailing newlines and spaces are allowed so specifying if they are might be a good idea.

Just a note... using String instead of StringBuilder in Java may cause bad performance. It's better use StringBuilder when you need to build a string. (don't argue with me that O(N) is O(1) when N is small, good coding practice is good anyway).

@user202729 But but O(N) is O(1) when N is small.

No one tell Leaky that alphabet challenges are back

Is lower case alphabet okay as well?

I guess that this is a lot easier than the other one at least in PHP: I can increment letters, but not decrement.

Ruby, 44 bytes
t=''
26.times{|x|puts' '*(12-x/2)+(t<<65+x)}

Try it online!

05AB1E, 5 bytes
Auη.c

Try it online!
Exlpanation
A        # push the alphabet
 u       # convert to upper case
  η      # get list of prefixes
   .c    # centralize, focused to the left

SOGL V0.12, 8 bytes
'⁸∫Zm}¹╚

Try it Here!
Explanation:
'⁸        push 26
  ∫  }    that many times, pushing the counter
   Zm       mold the alphabet to the counters length
      ¹   wrap the stack in an array
       ╚  center horizontally

You know your languages is built for kolmo challenges when you have a 'center horizontally' command.

C# (.NET Core), 114 + 18 = 132 bytes
Try It Online!
()=>string.Join("\n",new int[26].Select((i,e)=>"ABCDEFGHIJKLMNOPQRSTUVWXYZ".Substring(0,e+1).PadLeft(13+(e+1)/2)))

Can you use a function with a dummy argument (_=>) to save a byte?

thats what I usually do but OP said "No inputs" so I thought lets honor that requirement.

J, 38 36 bytes
echo(' '<@#"0~2#i._13),&><\u:65+i.26

Try it online!
This is honestly disgusting.
39 bytes
echo(2#i._13)(>@],~' '#~[)"0<\u:65+i.26

Explanation
These will be snippets of the code built up from a REPL session. Three spaces means an input, and no spaces means the output from it.
The alphabet
First we generate the alphabet by making the range [65,90] and converting this to unicode using u:.
   65 + i.10 NB. truncated
65 66 67 68 69 70 71 72 73 74
   u: 65 + i.26
ABCDEFGHIJKLMNOPQRSTUVWXYZ

Then we generate the A, AB, etc. sections by taking all of the prefixes of the alphabet and boxing them using <\
   <\ u: 65 + i.5 NB. truncated again
┌─┬──┬───┬────┬─────┐
│A│AB│ABC│ABCD│ABCDE│
└─┴──┴───┴────┴─────┘

The padding
We need to pad the alphabet with 12, 12, 11, 11, etc. spaces. So first we construct this range using i. with a negative argument (which makes it go from that value minus 1 to 0, descending).
   i. _13
12 11 10 9 8 7 6 5 4 3 2 1 0

We then copy each value twice
   2 # i. _13
12 12 11 11 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1 0 0

And then copy the space character as many times as specified, boxing it because J would pad the matrix with spaces to fill otherwise.
   '*' #"0~ 2 # i. _5 NB. truncated, and using '*' so you can see the output
****
****
***
***
**
**
*
*
    NB. This line is empty
    NB. This line is empty, too

Getting the output
Then we just join the two together using , (unboxing first using &>) and write to STDOUT using echo. There's nothing to show here since it's just the output.

Excel (VBA), 129 82 bytes
Using Immediate Window.  and cell [A1] as output.
For x=25to 0Step -1:For y=x to 25:b=b &Chr(65+y-x):Next:?Space(x/2.01)&b:b="":Next

You can make some small changes to get to For x=-25To 0:For y=Abs(x)To 25:b=b+Chr(65+y+x):Next:?Spc(x/-2.1)b:b="":Next or some bigger changes and get to For x=-25To 0:?Spc(x/-2.01);:For y=Abs(x)To 25:?Chr(65+y+x);:Next:?:Next (72 Bytes)

Noted and Thank you. :) Will apply it for future challenge :)

Perl 5, 32 bytes
say$"x(13-++$k/2),A..$_ for A..Z

Try it online!

C,  84  81 bytes
Thanks to @ceilingcat for saving three bytes!
f(i,j){for(i=1;i++<27;puts(""))for(j=51;j<63-~i/2;)putchar(j++<64-i/2?32:j+i/2);}

Try it online!
Unrolled:
f(i, j) // Using the argument list only to declare the variables.
{
    for (i=1; i++<27; puts(""))
        for (j=51; j<63-~i/2;)
            putchar(j++<64-i/2 ? 32 : j+i/2);
}

Jelly, 12 bytes
ØAJ’HU⁶ẋż¹ƤY

Try it online!
Uses code very similar to the linked question (further evidence that it is most likely a dupe).
-3 bytes thanks to FlipTack and Jonathan Allan (though indirectly)
Old version, 15 bytes
12Rx2U⁶ẋżØA¹Ƥ¤Y

Try it online!

You may want to look at this answer, though I suspect this question will soon be closed as a duplicate of that one anyway.

@FlipTack I've already VTC'ed, and thanks for the byte save!

Canvas, 6 bytes
øＺ［∔｝ｒ

Try it here!


text:
Match the Striking Clock
Introduction:
At home we have a clock that strikes the stated amount at each hour, but also strikes once at every half-hour. So from 0:01 to and including 12:00 it strikes in this order:
1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1, 12

Challenge:
Given an integer n, output a list of time-frames in which the total strikes are equal to n. In addition, always start at least 1 minute before this time-frame and end at least 1 minute after this time-frame (and at most 29 minutes).
For example, if the input is n=8, the output could be:
[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

For which these time-frames have the following sums, all equaling 8:
[1+1+2+1+3, 1+2+1+3+1, 3+1+4, 1+6+1, 1+7, 7+1, 8]

Challenge rules:

Output is flexible. You can output as Time (or Date/DateTime) objects, timestamps, strings (with or without leading zeroes), decimals with .29/.31/.59/.01 (i.e. 0.29-3.01 instead of 00:29-03:01), etc. As long as it's clear it's before and after the time-frame.
In addition, you can choose the amount yourself. In all my examples I use 1 minute, but you can also choose 5 minutes, 15 minutes, etc. This also means you can use .4/.6/.9/.1 (i.e. 0.4-3.1 instead of 00:24-03:06) for example.
The list is also flexible. Can be a list/collection, array, delimiter-separated string, printing per line to STDOUT, etc.
Please state which output choice you've made. Note: You are not allowed to output the sums of the time-frames like above, this is only mentioned as clarification. You must output the time-frames, including slightly before and after it.
The strikes do wrap around from 12:00 to 00:30. So if n=14, two of the time-frames are 11:29-00:31 and 11:59-01:01.
Input will be in the range 1 <= n <= 90, where 90 is the total sum of all possible strikes.
The time-frames you return can be in any order.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.

Test cases:
(all using 1 minute before / after the time-frames and leading zeroes)
Input: 8
Ouput:
[00:59-03:01, 01:29-03:31, 02:59-04:01, 05:29-06:31, 06:29-07:01, 06:59-07:31, 07:59-08:01]

Input: 14
Output:
[00:29-04:01, 00:59-04:31, 02:59-05:01, 04:29-06:31, 05:59-07:01, 11:29-00:31, 11:59-01:01]

Input: 90
Output:
[00:29-00:01, 00:59-00:31, 01:29-01:01, 01:59-01:31, 02:29-02:01, 02:59-02:31, 03:29-03:01, 03:59-03:31, 04:29-04:01, 04:59-04:31, 05:29-05:01, 05:59-05:31, 06:29-06:01, 06:59-06:31, 07:29-07:01, 07:59-07:31, 08:29-08:01, 08:59-08:31, 09:29-09:01, 09:59-09:31, 10:29-10:01, 10:59-10:31, 11:29-11:01, 11:59-11:31]

Input: 1
Output:
[00:29-00:31, 00:59-01:01, 01:29-01:31, 02:29-02:31, 03:29-03:31, 04:29-04:31, 05:29-05:31, 06:29-06:31, 07:29-07:31, 08:29-08:31, 09:29-09:31, 10:29-10:31, 11:29-11:31]

Input: 2
Output:
[00:29-01:01, 00:59-01:31, 01:59-02:01]

I'd go for whatever is most flexible. This includes decimal hour numbers, as long as the result numbers fall between two ringing times.

@Adám Guess you're right. I've edited my answer accordingly. You should have at least 1 minute and at most 29 minutes, so .4/.6/.9/.1 is allowed (being 6 minutes like you've stated: :24/:36/:54/:06).

Maybe mention that the time pairs may be returned in any order?

Ok n is in 0..90, I not find clear what is the time period for calculate the n strikes: It is 12 hours? They are 24 hours? Are 48 hours? Than are allowed return time in the format 0..24:0..60 ?

@RosLuP The time frame is a regular analog clock, so from 00:01 to 12:00. So instead of 0..24:0..60, it should be 0..12:0..60. How that clears any confusion.

APL (Dyalog Classic), 34 bytesSBCS
∪12|.4 .1∘+¨.5×⍸⎕=⍉∘.-⍨+\,⍪⍨1,⍪⍳12

Try it online!
This solution uses ⎕io←1 (1-based indexing).
From right to left:
⍳12 is 1 2 3...12
⍪ turns it into a tall thin 12x1 matrix
1, adds a column of 1s to the left
⍪⍨ concatenates the same matrix vertically, so it's now a 24x2 matrix
, flattens the matrix in row-major order, it becomes a vector of size 48: 1 1 1 2 1 3...1 12 1 1 1 2...1 12
+\ partial sums: 1 2 3 5 6 9...
∘.-⍨ the differences between each pair of elements, a 48x48 matrix
⍉ transpose
⎕= a 48x48 boolean matrix with 1s wherever the evaluated input (⎕) occurs
⍸ the pairs of coordinates of where the 1s are
.5× halve them
.4 .1∘+¨ add 0.4 to the first and 0.1 to the second coordinate in each pair
12| modulo 12
∪ unique

What is the time interval represented by .1 in the output? Also, nice answer.

Oh, and this is what makes it possible for this to be 34 bytes, maybe want to link to it or write SBCS just like Adám's answer.

@EriktheOutgolfer the problem explicitly allows .1/.4/.6/.9 instead of :01/:29/:31/:59. I don't need special encoding for this answer, it's in Dyalog Classic which has its own single-byte encoding.

⍸ isn't in Dyalog Classic. And yes, I do know that's explicitly allowed, I just wanted to know how many minutes is 0.1 in the output ;)

@EriktheOutgolfer "SBCS" added, thanks; .1×60 minutes is 6 minutes

@KevinCruijssen done

JavaScript (ES6), 104 bytes
Prints time intervals in H.MM,H.MM format.
F=(n,f=0,s=n,t=f++)=>t<f+23?F(n,f,s-=t&1||t/2%12+1,++t,s||alert([f/2%12+.01,-~t/2%12+.01])):f<24&&F(n,f)

Try it online!
Uses essentially the same algorithm as the non-recursive version below.

Non-recursive version, 117 bytes
Outputs a space-delimited string of time intervals in H.MM,H.MM format.
n=>[...Array(24)].map((_,f,a)=>a.map(_=>(s-=t++&1||t/2%12+.5)||(r+=[-~f/2%12+.01,-~t/2%12+.01]+' '),s=n,t=f),r='')&&r

Test cases

let f =

n=>[...Array(24)].map((_,f,a)=>a.map(_=>(s-=t++&1||t/2%12+.5)||(r+=[-~f/2%12+.01,-~t/2%12+.01]+' '),s=n,t=f),r='')&&r

console.log(f(8))
console.log(f(14))
console.log(f(90))
console.log(f(1))
console.log(f(2))

Commented
n =>                           // n = input
  [...Array(24)].map((_, f, a) // FOR f = 0 TO 23:
    => a.map(_ =>              //   FOR t = f TO f + 23:
      (                        //     update s
        s -=                   //       by subtracting:
          t++ & 1 ||           //         - 1 if t is odd (half hour)
          t / 2 % 12 + .5      //         - the current hour if t is even
      ) || (                   //     if s is equal to zero:
        r += [                 //       update the result string by appending:
          -~f / 2 % 12 + .01   //         - the formatted 'from' time
          ,                    //         - a comma
          -~t / 2 % 12 + .01   //         - the formatted 'to' time
        ] + ' '                //       and a padding space
      ),                       //     inner map() initialization:
      s = n,                   //     - s = target number of strikes
      t = f                    //     - 'to' time = 'from' time
    ),                         //   end of inner map()
    r = ''                     //   start with r = empty string
  )                            // end of outer map()
  && r                         // return r

APL (Dyalog Unicode), 62 59 bytesSBCS
Full program body. Prompts for n. Prints list of two-element lists using decimal hours.
∪(⎕=∊l+/¨⊂48⍴∊1,¨⍳12)/(¯.1 .1+⊃,⊢/)¨⊃,/(l←⍳48),/¨⊂.5×48⍴⍳24

Try it online!
⍳24 ɩndices 1…24
48⍴ cyclically reshape to length 48, i.e. 1…12,1…12
.5× multiply a half by that
⊂ enclose (to use this entire array as right argument for each left argument)
(…),/¨ for each of the following, return all the sub-lists of that length:
 ⍳48 ɩndices 1…48
 l← store in l (for lengths)
Now we have all the possible lists of runs of times for each possible run-length.
,/ concatenate (lit. concatenation-reduction) the lists of sub-lists
⊃ disclose (because the reduction reduced the rank from 1 to 0)
(…)¨ apply the following function to each:
 ⊢/ the last (lit. right-reduction) element (the end time)
 ⊃, prepend the first element (the beginning time)
 ¯.1 .1+ add negative and positive tenths to those
(…)/ filter those begin-end pairs with:
 ⍳12 ɩndices 1…12
 1,¨ prepend a 1 to each
 ∊ ϵnlist (flatten)
 48⍴ cyclically reshape to length 48, i.e. 1,1,1,2…1,11,1,12
 ⊂ enclose (to use this entire array as right argument for each left argument)
 l+/¨ for each of l (1…48) return the sums of all the sub-lists of that length
 ∊ ϵnlist (flatten)
⎕= compare numeric input to that
∪ return just the unique elements (begin-end pairs)

0.1 0.5 can become .1 .5

@Cowsquack Yeah, I noticed too. Thanks, though.

Python 3, 118 116 bytes
lambda n:[(a/2+.4,b%24/2+.1)for a in range(24)for b in range(48)if sum((sum(zip([1]*12,range(1,13)),())*2)[a:b])==n]

Try it online!
A timeframe is represented as (t1, t2), t1 and t2 being decimals representing hours. The offset is .1 or 6 minutes.

Batch, 196 bytes
@for /l %%i in (0,1,23)do @set s=%1&for /l %%j in (0,1,23)do @call:c %%i %%j
:c
@set/at=%2+%1,s-=t%%2*(t/2%%12)+1,h=%1/2,i=%1%%2*30+15,t=-~t%%24/2,u=-~t%%2*30+15
@if %s%==0 echo %h%:%i% %t%:%u%

Explanation: t is the time in half hours, starting at 0 for 00:30. The number of strikes at time t is then 1, 1, 1, 2, 1, 3 etc. Subtracting 1 gives the sequence 0, 0, 0, 1, 0, 2 etc. which is the integers interleaved with zeros. This can then be obtained by termwise multiplication of the sequence 0, 0, 1, 1, 2, 2 etc. with the sequence 0, 1, 0, 1, 0, 1 etc. Both of these sequences are readily calculated using modulo and (integer) division.
It then remains to loop over all 23 possible starting times, then taking all 24 striking times and subtracting the number of strikes from the input, printing the times when the result is zero.
The code falls through after the loop but no harm is done as the input cannot be more than 90.

APL NARS, 559 bytes
∇r←l w;t;i;j;c;k;m;p
p←{0=2∣¯1+⍵:.01+2÷⍨¯1+⍵⋄¯0.19+2÷⍨¯1+⍵}
m←{0=2∣¯1+⍵:¯.41+2÷⍨¯1+⍵⋄¯0.21+2÷⍨¯1+⍵}
   r←⍬⋄i←0⋄t←∊(¯1+⍳13),¨13⍴1⋄t←t,2↓t⋄k←⍴t
A: j←i+←1⋄→0×⍳i≥k⋄c←0
B: c+←j⊃t⋄:if(c=w)∧(0≤(m i))∧(24≥(p j))⋄r←r,⊂(m i),(p j)⋄:endif⋄→A×⍳c≥w⋄j+←1⋄→B×⍳j≤k⋄→A
∇
∇r←g w;v;i;k;m
   v←{12≤⌊⍵:⍵-12⋄⍵}
   i←1⋄k←⍴w⋄r←⍬
A: →0×⍳i>k⋄r←r,⊂v¨i⊃w⋄i+←1⋄→A
∇
h←g∘l

h(n) or l(n) returns all representative intervals in 0-24 hours that has n clock strikes.
h(n) has the clock format as 0..11.0..59; instead l(n) has clock  format as 0..23.0..59
test
  h 8
    0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01  6.59 7.31
    7.59 8.01  0.59 3.01  1.29 3.31  2.59 4.01  5.29 6.31  6.29 7.01
    6.59 7.31  7.59 8.01
  h 14
    0.29 4.01  0.59 4.31  2.59 5.01  4.29 6.31  5.59 7.01  11.29 0.31
    11.59 1.01  0.29 4.01  0.59 4.31  2.59 5.01 4.29 6.31  5.59 7.01
  h 90
    0.29 0.01  0.59 0.31  1.29 1.01  1.59 1.31  2.29 2.01  2.59 2.31
    3.29 3.01  3.59 3.31  4.29 4.01  4.59 4.31  5.29 5.01  5.59 5.31
    6.29 6.01  6.59 6.31  7.29 7.01  7.59 7.31  8.29 8.01  8.59 8.31
    9.29 9.01  9.59 9.31  10.29 10.01  10.59 10.31  11.29 11.01  11.59 11.31
  h 1
    0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31  4.29 4.31
    5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31  10.29 10.31
    11.29 11.31  0.29 0.31  0.59 1.01  1.29 1.31  2.29 2.31  3.29 3.31
    4.29 4.31  5.29 5.31  6.29 6.31  7.29 7.31  8.29 8.31  9.29 9.31
    10.29 10.31  11.29 11.31
  h 2
    0.29 1.01  0.59 1.31  1.59 2.01  0.29 1.01  0.59 1.31  1.59 2.01
  l 2
    0.29 1.01  0.59 1.31  1.59 2.01  12.29 13.01  12.59 13.31  13.59 14.01


text:
We had a question once which only failed on Sundays
Inspired by We had a unit test once which only failed on Sundays, write a program or function that does nothing but throw an error when it is Sunday, and exit gracefully on any other day.
Rules:

No using input or showing output through the usual IO methods, except to print to STDERR or your language's equivalent. You are allowed to print to STDOUT if it's a by-product of your error.
A function may return a value on non-Sundays as long as it doesn't print anything
Your program may use a Sunday from any timezone, or the local timezone, as long as it is consistent.
An error is a something that makes the program terminate abnormally, such as a divide by zero error or using an uninitialised variable. This means that if any code were to be added after the part that errors, it would not be executed on Sunday.
You can also use statements that manually create an error, equivalent to Python’s raise.
This includes runtime errors, syntax errors and errors while compiling (good luck with that!)
On an error there must be some sign that distinguishes it from having no error
This is code-golf, so the shortest bytecount in each language wins!

I'll have to wait til Sunday to check the answers ;)

Sandbox Post

Can the output be on STDOUT, as long it is generated by an error?

@Rod Yes you can

By "write a program or function that does nothing but throw an error on Sunday, and exit gracefully on any other day", do you mean that whenever it is run on sunday it should fail, or do you mean that there should be at least one possibility it fails a sunday. To make it clearer, if it fails only on sunday at 2pm, but not on sunday 3pm, is it fine ?

@Bromind It has to fail at any time on Sunday

Sad :'( I wanted to do something like
(time-time_of_first_sunday_after_epoch)%nb_of_second_per_week

If we use a function instead of a full program, may the function return something (which we don't use whatsoever)? To perhaps explain it better: In Java I have to assign a value when I use divide, so instead of ()->{1/sundayValue;} I'll have to use ()->{int x=1/sundayValue;}. This is a lambda with no parameter and no return-type. However, if I change this to a lambda with a return-type integer, I could do ()->1/sundayValue to shorten it. I don't use the output, and it still errors on division by 0, but I'm not sure if this is allowed?

@KevinCruijssen Sure. A function may return a value

This would have been even better if Saturday had been used. You could have called it "Saturday Night Error" and even worked in some adjusted song lyrics to the question.

I was confused after seeing some of the answers to this. Does the program/function itself need to produce some output which you are considering an error, or does the logic to determine if something is output need to be triggered by some error in the code? I had assumed the former, but others seem to be assuming the latter. With my interpretation, Dennis' answer could be shortened by 2 characters by removing the back-ticks, otherwise they are necessary.

Sundays? How about failing between midnight and 1am?

It's not clear from your question what constitutes an error.  I'm voting to close until this is remedied.

@WheatWizard Better?

Not really ... How can we distinguish the output of an error from regular output.  Is something like print "error" an error?  The added paragraph doesn't really clarify anything.

Bash + coreutils, 15 14 bytes
`date|grep Su`

Try it online!

PHP 7, 12 bytes
1%date("w");

On PHP 7 it throws an exception of type DivisionByZero on Sundays. The same happens if it is interpreted using HHVM.
On PHP 5 it displays a warning (on stderr) on Sundays:
PHP Warning:  Division by zero in Command line code on line 1

On any PHP version, it doesn't display anything on the other days of the week.
Run using the CLI:
php -r '1%date("w");'

or try it online!
Two more bytes can be squeezed by stripping the quotes (1%date(w);) but this triggers a notice (that can be suppressed by properly set error_reporting = E_ALL & ~E_NOTICE in php.ini).

I believe you must specify (in the title) that this answer is only and only for PHP7+ and for HHVM, since PHP5.6 and lower exit without any problem. Warnings aren't errors and don't stop the execution of the code. If you do 1%date("w");echo "Alive!", it will stop in PHP7+ and HHVM, but not in all the other versions since PHP 4.

@IsmaelMiguel the question classifies any printing to Standard Error as an error, so a warning's good enough in this case.

Quoting the question: "An error is a something that makes the program terminate abnormally, such as a divide by zero error or using an uninitialised variable.This means that if any code were to be added after the part that errors, it would not be executed on Sunday. ". This doesn't happen with a warning.

@IsmaelMiguel the paragraph you are quoting was added to the question less than one hour ago.

Quoting an older version, the one that was on at the time of the comment that I wrote: "[...] write a program or function that does nothing but throw an error when it is Sunday, and exit gracefully on any other day.". A warning is against this line because PHP will exit gracefully. An error would be a fatal error or a syntax error. Not a warning for dividing by 0. PHP 5.6 and older aren't valid for this challenge.

Java 8, 69 43 34 bytes
v->1/new java.util.Date().getDay()

-26 bytes thanks to @OlivierGrégoire.
-9 bytes thanks to @Neil.
Explanation:
Try it here.

v->{...} (unused Void null parameter) is one byte shorter than ()->{...} (no parameter).
new java.util.Date().getDay() will return 0-6 for Sunday-Saturday, so 1/... will give an java.lang.ArithmeticException: / by zero error if the value is 0, which only happens on Sundays.

v->{int i=1/new java.util.Date().getDay();} (43 bytes).

@OlivierGrégoire Ah, java.util.Date() does have a method to get the day of the week.. And it's even 0 for Sunday.. Not sure how I missed that. :S

Yup, usually the older classes have all the functionality in shorter names. ;-)

Is this valid for 34 bytes? Try it online!

@Neil it wasn't valid at the time you posted but became valid less than an hour later. ;-) It was my first idea, though...

PHP, 15 bytes
<?@date(w)?:\n;

Assumes default settings.
Output on Sundays
Fatal error: Undefined constant 'n' on line 1

Try it online!

Notice that this answer requires PHP 5.3+. An alternative could be ||\n instead of ?:\n.

Python 3, 33 bytes
import time
"Su"in time.ctime()>q

Try it online!
Python 3, 50 bytes
from datetime import*
datetime.now().weekday()>5>q

Try it online!
Saved ~3 bytes thanks to Rod.

@Rod Why not "Su"in time.ctime()>q (I was editing with this one)?

I can't quite grasp it. How does it work?

@pacholik "Su"in time.ctime() checks if the current day is Sunday. If this is false, the >q part isn't evaluated at all and everything exits smoothly. But if that is true, then the second part of the inequality is evaluated, and since q is not defined, this would throw a NameError.

If this is false, the >q part isn't evaluated at all — that's the thing – why not?

@pacholik Edit: I don't think I am wrong. For efficiency purposes, if the first part is falsy, then Python doesn't even bother to evaluate the last part. I'll have to wait until Sunday to test this, though. (I think) Demonstration.

@pacholik Note that Python chains boolean operators, so that is equivalent to ("Su" in time.ctime()) and (time.ctime() > q).

You imported everything from datetime, so you can use now() instead of datetime.now(), right?

@OldBunny2800 Nope, because the method is datetime.datetime.now(), not datetime.now().

Ah, makes sense.

JavaScript, 23 Bytes
Date().slice(1)>'um'&&k

Full program.
The variable k must not be defined.
JavaScript, 20 bytes by Rick Hitchcock
/Su/.test(Date())&&k

JavaScript, 19 bytes by apsillers
Date().match`Su`&&k

You forgot to include the _=>; without it this is a snippet which are not allowed by default. 2) This outputs false on every other day when it shouldn't output anything.

It's a full program, which is allowed by the OP. 2) If you run it as a program, there's no output

Nice solution. Also 23 Bytes: Date().indexOf("Su")||k

/Su/.test(Date())&&k for 20 bytes.

new Date version 25 bytes (new Date/864e5%7|0)-3||p

@l4m2 ah, someone ported my C version :)

The solution by @RickHitchcock can be made one shorter by template-tag execution on match instead: Date().match`Su`&&k

Pyth, 8 7 bytes
 l-6.d9

Try it online!
Explanation
    .d9 # Get the current day of week (0 = Monday, 6 = Sunday)
  -6    # Subtract 6 from the day
 l      # Try to calculate the log base 2 of the result of the previous operation raising a "ValueError: math domain error" on sundays
        # there is an extra space at the start, to supress the output on the other days

This is still invalid. Your output (1.0 is not generated by the error). The OP said explicitly that they don’t allow that. You can fix that by prepending a single space to your code, though

But you are not allowed to output to STDOUT unless it is Sunday, and you do output to STDOUT.

@Mr.Xcoder is correct. On non-Sundays nothing should be outputted

@JoKing I totally skipped this rule, fixed now

05AB1E, 45 44 bytes
As 05AB1E doesn't have a built in for getting the day of the week, I've used Zeller's Rule to calculate it.
Prints a newline to stderr in case of a Sunday (observable in the debug view on TIO)
žežf11+14%Ì13*5÷žgžf3‹-т%D4÷žgт÷©4÷®·(O7%i.ǝ

Try it online!
Explanation
The general formula used is
DoW = d + [(13*(m+1))/5] + y + [y/4] + [c/4] - 2*c
Where DoW=day of week, d=day, m=month, y=last 2 digits of year, c=century and and expression in brackets ([]) is rounded down.
Each month used in the formula correspond to a number, where Jan=13,Feb=14,Mar=3,...,Dec=12
As we have the current month in the more common format Jan=1,...,Dec=12
we convert the month using the formula
m = (m0 + 11) % 14 + 1
As a biproduct of March being the first month, January and February belong to the previous year, so the calculation for determining y becomes
y = (year - (m0 < 3)) % 100
The final value for DoW we get is an int where 0=Sat,1=Sun,...,6=Fri.
Now we can explicitly throw an error if the result is true.

05AB1E losing to Java? Everything I know is a lie

Haskell + Data.Dates, 55 bytes
import Data.Dates
succ.dateWeekDay<$>getCurrentDateTime

Try it online!
This uses the fact that Sunday is the last day of the week. dateWeekDay returns the day of the week as a WeekDay type, which is simply defined as
data WeekDay = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday

WeekDay is an instance of Enum, thus we can use succ and pred to get the successor or predecessor of a weekday, e.g. succ Monday yields Tuesday.
However, Sunday is the last enum entry, so calling succ Sunday results in the following error:
fail_on_sunday.hs: succ{WeekDay}: tried to take `succ' of last tag in enumeration
CallStack (from HasCallStack):
  error, called at .\Data\Dates.hs:56:34 in dates-0.2.2.1-6YwCvjmBci55IfacFLnAPe:Data.Dates

Edit 1: Thanks to nimi for -3 bytes!
Edit 2: -11 bytes now that functions are allowed.

Full program: 88 81 74 69 66 bytes
import Data.Dates
main=pure$!succ.dateWeekDay<$>getCurrentDateTime

Try it online!
pure is needed to lift the resulting WeekDay back into the IO Monad. However, Haskell sees that the value is not output in any way by the program, so lazy as it is, the expression is not evaluated, so even on Sundays the program would not fail. This is why $! is needed, which forces the evaluation even if Haskell would normally not evaluate the expression.

Previous approach with Data.Time: 127 124 bytes
import Data.Time.Clock
import Data.Time.Calendar.WeekDate
c(_,_,d)|d<7=d
main=getCurrentTime>>=(pure$!).c.toWeekDate.utctDay

Try it online! These are some impressive imports. Change d<7 to e.g. d/=5 to test failure on a Friday. Fails with the following exception: Non-exhaustive patterns in function c.

main=pure$!succ.dateWeekDay<$>getCurrentDateTime. And, as functions are allowed, you can drop the main=.

@nimi Thanks! I'm not sure about the function though, because of the No using input or showing output through the usual IO methods rule. As far as I see, using a function would result in an output for non-Sundays, even though it is wrapped in an IO-action.

Maybe you're right, but on the other hand a full program has an exit code, which is also a standard method.

... the challenge rules now allow functions to return values on non-Sundays as long as they don't print.

@nimi Thanks for the notice.

Ruby, 15 bytes
1/Time.now.wday

wday will return 0 on Sunday causing a ZeroDivisionError: divided by 0 error. For example: 1/Time.new(2018,1,7).wday.

VBA / VBScript, 22 20 bytes
Saved 2 bytes thanks to Taylor Scott.
a=1/(Weekday(Now)-1)

This should be run in the Immediate Window. Weekday() returns 1 (Sunday) through 7 (Saturday) so this creates a divide by zero error on Sunday. Otherwise, no output.

You beat me to an answer by an hour - 19 Bytes: ?1/(Weekday(Now)-1)

@TaylorScott I forgot that Now is valid without the () in VBA but I can't use print because I think all output is disallowed unless it errors out. No using input or showing output through the usual IO methods, except to print to STDERR. Still, saved 2 bytes.

I had just written these exact 20 bytes as a VBScript solution, and then I thought I'd look to see if there was an existing VB-style language already submitted and here it is. So, this works for VBScript and probably other VB-style languages as well.

@EngineerToast I think you should mark this as a polyglot with VBScript

@TaylorScott I haven't done that before. Did I do it right?

@EngineerToast as far as I know yes :P but for the future, if you end up with more then will fit in a single line its standard to mark it as Polyglot,  n Bytes and then indicate what languages it works with below

Perl 5, 13 bytes
1/(gmtime)[6]

Try it online!
Ported @biketire's answerj
removed 3 bytes with @mik's reminder

gmtime instead of localtime will also meet the rules, and is 3 bytes shorter

TI-Basic 84+, 23 bytes
getDate
0/(1-dayOfWk(Ans(1),Ans(2),Ans(3

Needs date & time commands, which are 84+ and higher only.

C, 35, 34 27 bytes
f(n){n/=time(0)/86400%7^3;}

-7 bytes with thanks to @MartinEnder and @Dennis
Try it online!

Welcome to PPCG!

Vyxal O, 25 bytes
kðtD4/‟₀/N‟:400/kτṠ7%2<[←

Try it Online!
Vyxal doesn't have a weekday function, so I made one myself.

R, 31 bytes 30 bytes
if(format(Sys.Date(),'%u')>6)a

Try it online!
No output on non-Sundays, Error: object 'a' not found on Sundays.
format(Sys.Date(),'%u') was the shortest way I could find to get weekday, it outputs a character-class number for day of week, with 7 for Sundays. We can compare to a numeric 7, and if true attempt to use an undefined object.
Saved a byte thanks to Giuseppe!

>6 is a byte shorter.

Zsh -G, 14 bytes
>`date`
dd Su*
Attempt This Online!

date: get the date in the format Sun 28 Mar 07:55:54 BST 2021
>: create a file named according to each of the words in the output
dd: "copy and convert" - here it basically does nothing

this command expects no arguments

Su*: search for a file starting with Su

if a file matching that exists (which happens when it is Sunday), then it is passed to dd

since dd expects no arguments, this produces an error

with the -G option: if no file matches (i.e. it is not Sunday), don't error as usual

This produces a bit of extra junk output to STDERR (not an error though) which may or may not be allowed; the question isn't really clear. Here's an alternative answer which doesn't:
Zsh -G, 18 bytes
>`date`
mv <-> Su*
Attempt This Online!
<-> matches any file whose name is a number, of which there are two: the day of the month, and the year.
When there is no Su* file, this is renames the day of the month to the year (overwriting the year), which works fine.
When Sun exists, it tries to move the day of the month and the year into the directory Sun, which fails because Sun is a file, not a directory.

C,  68  55 bytes
Thanks to @Ken Y-N for saving 13 bytes!
#import<time.h>
f(n){time(&n);n/=gmtime(&n)->tm_wday;;}

Try it online!

Drop the intermediate d to get n/=gmtime(&n)->tm_wday; for 54 bytes (but I'm not sure I like all these compiler warnings...)

jq, 42 characters
(39 characters code + 3 characters command line option)
now|strftime("%w")|strptime("%d")|empty

Just trying a different approach here: parse week day number (0..6) as month day number (1..31).
Sample run:
bash-4.4$ TZ=UTC faketime 2018-01-06 jq -n 'now|strftime("%w")|strptime("%d")|empty'

bash-4.4$ TZ=UTC faketime 2018-01-07 jq -n 'now|strftime("%w")|strptime("%d")|empty'
jq: error (at <unknown>): date "0" does not match format "%d"

Note that jq only handles UTC dates.
Try it online!

MATL, 12 bytes
vZ'8XOs309>)

The error produced on Sundays is:

Interpreter running on Octave:
MATL run-time error: The following Octave error refers to statement number 9:  )
---
array(1): out of bound 0

Interpreter running on Matlab:
MATL run-time error: The following MATLAB error refers to statement number 9:  )
---
Index exceeds matrix dimensions

To invert behaviour (error on any day except on Sundays), add ~ after >.
Try it Online!
Explanation
This exploits the fact that

indexing into an empty array with the logical index false is valid (and the result is an empty array, which produces no output); whereas
indexing with true causes an error because the array lacks a first entry.

Commented code:
v       % Concatenate stack. Gives empty array
Z'      % Push current date and time as a number
8XO     % Convert to date string with format 8: gives 'Mon', 'Tue' etc
s       % Sum of ASCII codes. Gives 310 for 'Sun', and less for others
309>    % Greater than 309? Gives true for 'Sun', false for others
)       % Index into the empty array
        % Implicit display. Empty arrays are not displayed (not even newline)

Q, 20 Bytes
if[1=.z.d mod 7;'e]

.z.d returns the current date. mod does the modulo of the current date, which returns an int. If the date is a sunday, .z.d mod 7 returns 1.
    If 1=1, (on sunday), and error is raised using the ' operator
For brevity the error is just the e character.

Welcome to PPCG!

Julia 0.6, 32 bytes
Thanks to @Dennis for pointing out < saves a byte over !=.
@assert Dates.dayofweek(now())<7

Try it online!

VBA 18 bytes
This relies on the inbuilt function date() returning a day number that remainders 1 if divided by 7, so may be OS and/or CPU specific.
a=1/(date mod 7-1)

It runs in the VBA project Immediate window.

Welcome to PPCG! In general, an explanation and a link to an online compiler/interpreter is appreciated.

@tfbninja - ok updating

and, if necessary, instructions for how to use, e.g. function call or variable

Nice golfing, was just about to post this myself after seeing the other answer!

Excel, 24
Closing quote and paren not counted toward final score, as Excel will autocorrect both of those. Tested in Excel 2016.
=IF(MOD(TODAY()-1,7)^0,"")

I think this is different from the other submission enough to warrant another answer.
How it works:

I've rolled the error into the conditional check. As it turns out, TODAY() mod 7 also gives the weekday. If it's a Sunday, this means that MOD(TODAY()-1,7) is 0, and 0^0 is an error in Excel.

Of course, I could also have divided 1 by the MOD() value or used +6 instead of -1.

If it's not Sunday, the MOD(...,7) will be non-zero, which when raised to 0, returns 1, a truthy value. This makes the IF return an empty string (our "nothing").
The if statement, therefore, cannot evaluate to FALSE, because it errors or returns nothing.

Alternative
Here's one that works just as well, but uses a Name error instead:
=IF(MOD(TODAY(),7)=1,A,"")

TI-Basic, 22 21 bytes
getDate
log(log(dayOfWk(Ans(1),Ans(2),Ans(3

-1 byte by using MarcMush's method but replacing ln( with log(.
Only works on TI-84+/SE. Assumes that the date is set correctly before the program is run. There is a newline at the end.

C# (.NET Core), 55 54 48 bytes
Try it online!
Saved 1 byte thanks to Shaggy
Saved 5 byte thanks to Emigna
Saved 1 byte thanks to Kevin Cruijssen
_=>{var k=1/(int)System.DateTime.Now.DayOfWeek;}

Lucky that Sunday is indexed 0 in enum or else it would've needed to be (System.DayOfWeek)7

54 bytes?

Do you get using System for free in C#? If so I think you could do ()=>{var k=1/(int)DateTime.Now.DayOfWeek;} for 42. Otherwise 49 with the explicit System.

@Emigna beat me to it; ()=>{var k=1/(int)System.DateTime.Now.DayOfWeek;} is shorter. And you can save one more byte by using an empty unused parameter instead of no parameter (i.e. v->{...} instead of ()->{...})

40 bytes: ()=>1/(int)System.DateTime.Now.DayOfWeek. Try it here.

APL (Dyalog), 23 bytes
⎕CY'dfns'
o←÷7|⌊days⎕TS

Try it online!

Ocaml, 46 bytes
open Unix
let()=1/(gmtime(time())).tm_wday;()

and in the ocaml REPL, we can achieve better by removing the let and the final :():
$ open Unix;;1/(gmtime(time())).tm_wday;;<CR>

which is 41 bytes (incuding 1 byte for the carriage return).

Welcome to PPCG!

Is it possible to make this code work on Try it online?

Mmh... the compile command is ocamlopt unix.cmxa , I don't know how to give compile option on tio. I'll investigate this evening

The tio uses a (simili) REPL interpreter, so you should use the 2nd possibility. However, it doesn't seem to have the Unix library (or don't allow access to it, for any reason)

SAS, 36 bytes
%put %eval(1/(1-%index(&sysday,Su)))

Julia 0.5, 28 bytes
Dates.dayofweek(now())<7||~-

Try it online!
This does not work with 0.6, but it does with 0.4.

Groovy, 16 bytes
1/new Date().day

Try it online!

Welcome to PPCG!

Thanks!
Also, thanks for editing! I was not sure which online playground to choose. Now I know. :)

Zsh, 15 bytes
${(%):-%(w._.)}

Try it online!
Prompt sequences can be really crazy sometimes...
${(%):-%(w._.)}
${(%)         }   # expand as prompt sequence
     :-           # ${var:-fallback}, but without the var
       %( . .)    # Prompt ternary
         w        # If DoW matches given number (implied 0, which is Sunday)
          ._      # Then substitute _
            .     # Else substitute nothing

Since _ is not a command, it fails on Sunday.

R, 40 bytes
stopifnot(weekdays(Sys.Date(),T)!="Sun")

Try it online!
weekdays returns the weekday of the date, with an optional argument abbreviate, which shortens Sunday to Sun, saving a single byte.
stopifnot throws an error if, for each argument, not all are TRUE, and throws an error with a message indicating the first element of which isn't TRUE, so the error is Error: "Sun" is not TRUE

Got it down to 31 with a slightly different approach

Gema, 40 characters
\A=@subst{Su=\@err\{S\}\;*=;@datime}@end

Had to specify an error message, so choose a short one: “S”.
Sample run:
bash-4.4$ faketime 2018-01-06 gema '\A=@subst{Su=\@err\{S\}\;*=;@datime}@end'

bash-4.4$ faketime 2018-01-07 gema '\A=@subst{Su=\@err\{S\}\;*=;@datime}@end'
S

Funky, 21 bytes
if!os.date"%w"error()

os.date"%w" returns the current day of the week in 0-6 format, where 0 is sunday. Getting the logical not of that is only true when the weekday is 0, so Sunday. Then just a basic if(a){error()} will assure that this program only errors on sunday
Try it online!

Perl 6,  29  21 bytes
die if now.Date.day-of-week>6

Try it
die if now/86400%7+^3

Try it

Pure bash BASH (interactive mode + no coreutils required), 17 20 19 bytes
PS1='`((1/\D{%w}))&&:`'

Now only 19 bytes thanks to manatwork's comment below.
Bonus, if you put it in your bashrc it fails every sunday you log in :-) not just when you run it on sundays!

Nice, but on non-Sunday days should output nothing.

now it outputs nothing on non sundays.

You can save 1 character using professorfish's tip.

You should mark this as Bash REPL, as this won't fail in a Bash script/full program.

Postgresql, 32
Not sure if you need to add ; at the end for valid answer
SELECT 1/EXTRACT(DOW FROM now())

Excel, 77 30 bytes
Yes, vastly more golfable.

=IF(WEEKDAY(TODAY())=1,1/0,"")

Simply checks if it's Sunday, and if so, finds the quickest way I know of to error. If not Sunday, returns "",the closest Excel has to not returning anything

C# (.NET Core), 39 43 41 bytes
_=>{if(1/(int)DateTime.Now.DayOfWeek<0);}

Try it online!
Thanks to @caird coinheringaahing and @Jo King

Welcome to the site! You can remove the leading newline in your answer to save one byte. Also, it seems as though this is a snippet, rather than a program or a function. If this is the case, you can prepend a _=> to make it a valid submission.

@caird coinheringaahing - Is it allowed to have a warning like i currently have?

It should be, but I would ask under the question, so that the author can decide.

A warning is fine. Could you also use <0 instead of ==-1 to save 2 bytes?

Yes I could, good idea, thanks!

SmileBASIC, 20 bytes
DTREAD OUT,,,W
W=W/W

DTREAD outputs the current year, month, day, and day of the week. Sunday is 0.

Java 8, 34 bytes
Returns 1 on Mondays, 0 on other days, and throws an ArithmeticException on Sundays
v->1/new java.util.Date().getDay()

Try it online!

05AB1E, 54 52 bytes
žg¦¦D4÷že+•YFóåι•žf<è+žg4Öžf3‹&-ŽPjžg2£4%è++7%iõEëõ}

Try it online!
Explanation
Formula from here.
žg¦¦                                                 # Take the last two digits of the year.
    D                                                # Save for later.
     4÷                                              # Divide by 4, discarding any fraction.
       že+                                           # Add the day of the month.
          •YFóåι•                                    # Push the month's key values.
                 žf                                  # Take the month.
                   <è                                # Find the month's key value.
                     +                               # Add the month's key value.
                      žg4Ö                           # Is this year a leap year?
                          žf3‹                       # Is it January or Feburary?
                              &                      # And the results of both questions.
                               -                     # Subtract 1 for January or February of a leap year.
                                ŽPj                  # Push 6420.
                                   žg2£              # Take the first two digits of the year.
                                       4%è           # Index the thing into the list.
                                          +          # Do step 6.
                                           +         # Add the last two digits of the year.
                                            7%       # Divide by 7 and take the remainder.
                                              i  ë } # Sunday is 1, so it goes in the if.
                                              iõ ë } # Push empty string.
                                              i Eë } # For loop.
                                              i  ëõ} # If not sunday, push empty string and implicit output.

Pyth, 7 bytes
/1-6.d9

Try it online!
/1-6.d9
    .d9  // Current day of the week, 0 indexed on monday.
  -6     // 6 - day of week (0 if Sunday)
/1       // 1 ÷ ^

Japt, 7 bytes
çKe ªUí

Test it
çKe ªUí
ç           :U=0 times repeat
 K          :  Current date
  e         :  0-based day of the week
    ª       :  Logical OR with
     Uí     :  The result of running the í method on U, which doesn't exist for numbers

Python 3, 50 bytes
from datetime import*
1/(date.today().weekday()-6)

Try it online!

Batch, 88 bytes
@for /f "skip=1" %%d in ('wmic path win32_localtime get dayofweek')do @set/a1/%%d&exit/b

Tries to divide by zero on Sunday.
Unfortunately neither date nor powershell date work on my PC to give me the day of the week.

PowerShell, 24 20 Bytes
1/(date).DayOfWeek>1

Sunday triggers divide by zero same as most of the other solution here. Problem is that on other days that a double gets returned so redirect to nowhere useful trumps that output.

AWK, 27 25 23 21 bytes
END{1/strftime("%w")}

Try it online!
Saved 4 bytes thanks to manatwork
Saved 2 bytes thanks to mik

But strftime() also handles “%w     The day of the week as a decimal, range 0 to 6, Sunday being  0.”, according to man 3 strftime.

Ok, but now you can remove the outer parenthesis too.

Whoops, thats what i get for rushing

END instead of BEGIN will also work

Swift 4, 78 bytes
import Foundation;if(Calendar.current.component(.day,from:Date()))==7{exit(1)}

Try it online!

70 bytes

Octave, 23 22 bytes
(1:6)(weekday(now)-1);

Try it online!
This will try to access an element in 1:6. When the day is Sunday it will try to access the element (1-1)=(0) which will result in an error as MATLAB is 1-indexed.

Original for 23.
assert(weekday(now)~=1)

Try it online!
assert(...) will throw an error when the condition is false. weekday(now) returns the current day of the week where 1 = Sunday. Put the two together, the code will throw an error only on sundays when the condition becomes 1~=1.

Clojure, 43 bytes
#(and(=(.getDay(java.util.Date.))7)(/ 1 0))

Try it online!
Uses the fact that and doesn't evaluate the second argument unless necessary. I originally thought I could get away with using the Ratio literal 1/0 to save two bytes, but that unfortunately causes exceptions immediately. It must try to reduce the Ratio right away or something.
(defn sunday-fail []
  (and (= (.getDay (Date.)) 7)
       (/ 1 0)))


text:
Zigzag a string
A zigzag scan is a method of encoding 2D information in one dimension:

Write a function or program that, given a one-dimensional string of printable ASCII characters, will reverse the zigzag scan to arrange its characters into a square.
For example, given the input string ABeIfCDgJmnKhLop, your program should return:
ABCD
efgh
IJKL
mnop

Here it is with the zigzag illustrated. The green line shows the order of the original characters, starting at the top left:

The side length  of the output (i.e. the number of rows and columns) for an input string of length  must equal ⌈√̅⌉ (ceil(sqrt(n))). The zigzag pattern is slightly different for even and odd values of . Note how to upper right corner of the zigzag in the below example ( = 5) differs from the above ( = 4).
Given the string Woamnlfgasa d gAeMrtouz, your output should be:
Wolfg
ang A
madeu
s Moz
art

That is:

Winning
This is code-golf. The solution with the fewest bytes win.
Rules
Input must be taken as a single string or list of characters. It may not have any extra whitespace, but for a single trailing newline. The input (sans newline) will have length 1 ≤  ≤ 4,096.
Output must be a string with multiple lines, a list of strings, or a list of lists of characters. Trailing whitespace (any amount) on each line is allowed but optional, as is a single trailing newline.
Standard loopholes are forbidden.
Test cases
The below test cases are formatted as:

Input

Output
...

$

$

PPCG

PP
CG

foobarbaz

for
oab
baz

Ooo...    ...ooO

Oo.
o. .
. .o
 .oO

OOo.oOOo.oOo.oOo.oOOo.oOO

OOOOO
ooooo
.....
ooooo
OOOOO

PrmPmogiusC znragzaooldnl edef   G

Progra
mming
Puzzle
s and
Code G
olf

The quick brown fox jumps over the lazy dog

Thuin v
eqcwfoe
 koo ry
 rxs z
b ptad
jmhlo
ue g

Sandbox post

Related

Related. (The opposite conversion and on matrices instead of strings.)

@MartinEnder Oh for heaven's sake. I searched for ages. Apparently the keyword I was missing was "zigzagify." In fact, this other challenge of yours (the reverse operation) is pretty much a duplicate. I really wish this had come up in the sandbox.

Oh, I completely forgot that I did both directions of this conversion... in that case yes, that's a very close match.

I think I need to just start posting very, very rough drafts in the sandbox, and then harassing people in chat non-stop to actually read them before I put so much work into them.

Why are people nominating this for reopening? This is an exact duplicate of the other question.

@cairdcoinheringaahing I’m not sure, but this challenge appeals to me over the other one because the languages I like to golf in (Ruby, sed) have string manipulation capabilities that just make this one more fun.