Problemang Sikat

This is still a work in progress. It may be changed in the future.

Problemang Sikat (literal Filipino/Tagalog translation of "Popular Problem(s)") is an esoteric programming language by User:Raiseafloppafan7741 in 2026 that was made to efficiently solve popular problems but steered far off course. Its goal is not anymore necessarily to have the shortest solution out of all languages in bytes or characters, but to at least have short and "elegant" solutions for all of these problems. These "elegant" solutions do not however, concern themselves with their byte count.

Reference

Problemang Sikat is based on applying functions to other functions to compound their functionalities. (See what I did there?)

All functions can only take one parameter, however said parameter is actually a tuple. The tuple may be of any length, with tuples of length zero being implied. For example, H is the same as H(), but one is shorter because of the implicit empty tuple. Additionally, functions may look like they're taking in other values and not tuples like in the cat program C y, and that is because non-tuples are implicitly turned into one-element tuples, therefore y C is equivalent to y (C).

' is a character literal. It takes the next character and turns it into a one-character string. For example, 'A becomes the string A.

() defines a tuple. It may be empty, which would make it the empty tuple, or it can contain values.

{} defines a block. This block is a function.

Base functions

These functions are the "base functions" of the language, those which are not oriented towards solving a specific popular problem.

The y function prints its argument with a newline, while z does not.

` is a "function suppressor". It prevents functions from being invoked by just existing — for example `T will not run the truth-machine. This can be used to make "precedence" rules, for example in the one time cat program @(`y{C 1}), it prevents y from consuming the code block {C 1}. It is not really a "function" just like the ' symbol as it only works during parse time and prevents the parser from parsing a function call.

n is a function returning the empty tuple.

! is a unary function that returns 1 if its arguments are falsy (0 or the empty tuple ()) and 0 if truthy.

= is a binary function that returns 1 if its arguments are equal, otherwise returns zero.

> and < are greater than and less than respectively. They are both binary functions.

+ as a unary function increments its argument. For example, + 1 returns 2. When applied to a range, it increments both endpoints. As a binary function, it performs arithmetic addition and string concatenation.

- as a unary function decrements its argument. For example, - 0 returns -1. When applied to a range, it decrements both endpoints. As a binary function, it performs arithmetic subtraction.

* as a unary function squares its argument. For example, * 1.414 is the same as 1.414 * 1.414. As a binary function, it performs arithmetic multiplication, and if given a string and a number then it will multiply the string like in Python. For example, * 'a 10 returns aaaaaaaaaa.

/ as a unary function gets the reciprocal of its argument. For example, / 2 is 0.5. As a binary function, it performs arithmetic division. If the divisor is zero, then it returns the empty tuple.

% is the binary modulo (not remainder, MODULO) function. If the divisor is zero, then it returns the empty tuple.

? is a conditional expression. As a ternary function, it evaluates the first argument and if it is truthy (not zero and not an empty tuple) then it returns the second argument, otherwise the second argument. As a binary function, it returns the second argument if the first is truthy, otherwise the empty tuple.

@ is a function invoker. As a unary function, it takes in a function and invokes it. Any additional arguments after the first are treated as arguments to the function being invoked.

Z is a unary function that converts its argument to an integer, and returns zero if the conversion failed. If the input is a real number that is not an integer, it is rounded down towards zero.

R is a unary function that converts its argument to a number, and returns zero if the conversion failed.

↥ is a function that returns a range. As a unary function that takes in a number, it returns an inclusive range from 0 to N, or in interval notation [0, N]. As a binary function taking two numbers A and B, it returns an inclusive range from A to B, or in interval notation [A, B].

↑ is similar, except it returns a range with an exclusive upper bound. In the unary case, it returns an exclusive range [0, N) and in the binary case, it returns [A, B).

"Hello, world!"

The H function corresponds to the "Hello, world!" program.

As a nullary function, H returns a string containing Hello, world!.

As a unary function, it takes in an integer corresponding to the "Hello, world!" variant in the following table and returns that string.

Number	Variant
0 (default, implied in nullary)	Hello, world!
1	Hello, World!
2	Hello World!
3	Hello World
4	Hello world!
5	Hello, world
6	Hello world
7	hello world
8	hello, world
9	hello, world!
10	hello world!
11	HELLO, WORLD!
12	HELLO WORLD!
13	HELLO, WORLD
14	HELLO WORLD

Cat program

The C function corresponds to the cat program.

As a nullary function, it reads user input up until EOF and returns that string.

As a unary function taking in a number, it reads N Unicode characters of user input and returns that string.

If C is treated as a unary function taking in another function, the behavior changes depending on the function. If the function is not in the table below, returns an empty string.

Function	Behavior
Z	Reads an integer.
R	Reads a number, integer or not.

Truth-machine

The T function corresponds to the truth-machine.

As a unary function, it takes in a number or string and checks if it is equal to 1 or "1". If it is, then it returns an infinite string of "1"s. (This requires lazy evaluation of strings) Otherwise, it returns its input.

As a ternary function, it takes in the input followed by the key followed by whether the key is the key or the rejected value. For example, T ("A" "A" 1) returns an infinite string of As and T (100 1 0) returns an infinite string of 100s.

Quine

The Q function corresponds to a quine. It is a nullary function that returns the program's source code.

99 bottles of beer

The N function corresponds to 99 bottles of beer.

As a nullary function, it returns this variant of 99 bottles of beer.

99 bottles of beer on the wall,
99 bottles of beer.
Take one down, pass it around,
98 bottles of beer on the wall.

98 bottles of beer on the wall,
98 bottles of beer.
Take one down, pass it around,
97 bottles of beer on the wall.

...

2 bottles of beer on the wall,
2 bottles of beer.
Take one down, pass it around,
1 bottle of beer on the wall.

1 bottle of beer on the wall,
1 bottle of beer.
Take one down, pass it around,
No bottles of beer on the wall.

No bottles of beer on the wall,
No bottles of beer.
Go to the store, buy some more,
99 bottles of beer on the wall.

As a unary function that takes in an integer, the following variations are returned instead in a similar way to the H function.

Number	Variant
0 (default)	The one you just saw above this table.
1	Common grammatical mistake, 1 bottles
2	Another common grammatical mistake, 0 bottles
3	1 bottles and 0 bottles at the same time

Fibonacci function

The F function is a unary function that takes in a positive integer starting from zero and returns the Nth term of the Fibonacci sequence. For example, F 0 returns 0, F 20 returns 6765, and so on.

Gamma function

There is no factorial function, but there is the gamma function Γ. It is just the gamma function.

The kids choice awards

滑り is a nullary function that returns an infinite string containing slime repeated forever. That is Japanese for "slime".

XKCD Random Number

四. You already know.

Miller-Rabin primality test

The IP function is a unary function that takes in an integer and returns the probability that it is prime.

Examples

"Hello, world!" program

y H

One that prints "Hello World!"

@(`y{H 2})

A non-trivial one that you'd expect from a "normal" language

y "Hello, world!"

Cat program

y C

One Time Cat

@(`y{C 1})

Truth-machine

One that outputs 1 infinitely and rejects everything else:

T C

One that only rejects 0

T (@{C} n 0)

One that only accepts a string "Key"

T (@{C} n "Key")

99 bottles of beer

y N

Narcissist

@({y} ?(=(Q C) "accept" "reject"))

A+B Problem

y +(@{C R} @{C R})

Fibonacci

y F@{C Z}

Factorial

Not winning any golf competitions any time soon in terms of byte count.

y Γ+@{C Z}

With clearer precedence

y Γ( +( @{C Z} ) )

With detailed description

y Γ( +( @{C  Z} ) )
| |  |  |     |
| |  |  +--+--+
| |  |     |
| |  |     +----------- read user input as an integer
| |  +----------------- unary plus, increment (user input)
| +-------------------- gamma function
+---------------------- print

XKCD Random Number

y 四

Another more boring one

y ++++0

Detailed explanation

y +( +( +( +(0) ) ) )
| |  |  |  |
| |  |  |  +------------ increment 0 -> 1
| |  |  +--------------- increment 1 -> 2
| |  +------------------ increment 2 -> 3
| +--------------------- increment 3 -> 4
+----------------------- print 4

Another even more boring one

y 4

The kids choice awards

y 滑り

See also

• Popular problem
• Category:Program forms
• HQ9+
• ™ - A family of languages optimized for truth-machines.
• Polynomix and Uiua - The inspirations for the functional paradigm.