text:
Print the Lost numbers
As a big fan of the Lost TV series, I always got intrigued by the sequence of numbers that repetitively appears on the episodes. These numbers are:
\$ 4, 8, 15, 16, 23, 42\$ (A104101)
Using any programming language, write a code that outputs these numbers.
Scoring:

Shortest answer wins
The output must not contain any other numbers or letters. You may use any other character as separator, or even no separator at all.
You cannot separate digits of the same number. \$ 48\_15162342 \$ is a valid answer, but \$481\_5162342\$ is not.
You must respect the order.
If your code does not contain any of the numbers from the sequence, reduce your score by 30%. This rule does allow you to enter the digits separately. E.g.:
abcde1fg5h

Is a valid candidate because the answer does not contain the number \$15\$, only its digits. However, any \$4\$ or \$8\$ will invalidate the bonus.
If the code does not contain any digit at all, reduce your score by 50%. Other characters like \$¹\$, \$²\$ or \$³\$ are still valid for this bonus.

Related, closed question: https://codegolf.stackexchange.com/q/23808/67312

Vaguely related: Are you lost yet?

Do we have to print them in that order?

For future reference, we have a restricted-source tag that could have been used here: although most answers are avoiding obvious solutions, I think the challenge would have been slightly more interesting if using digits were forbidden altogether.

Can the two reducers stack?

Lost, 29 27/2 = 13.5 bytes
%?\>>>>>>>>>>
>>\"*"@"

Try it online! or verify that it is deterministic
Seemed like the right language to use.
Explanation:
Lost is a 2D language where the pointer starts anywhere, going in any direction. This generally leads to a lot of double checking that the pointer hasn't entered a section early.
...>>>>>>>>>>  These arrows filter all pointers that appear on the top line
.............  Or going vertically

%............  This flips the flag so that the program can end
.............  This stops premature termination

.?\..........  Clear the stack by skipping if a value popped from the stack is positive
.............  When the stack is empty, the \ directs the pointer down

.............  The \ directs the pointer right
..\"*"..  The string literal pushes all the Lost values to the stack

..\..........  The @ terminates the program if the % flag is switched
>>\........@.  Otherwise it clears the stack and repeats

.............  The quote here is to prevent the pointer getting stuck
............"  This happens when the pointer starts between the other quotes

1 byte shorter (keeps the bonus)

... and 2 bytes shorter

Jelly, 7/2 = 3.5 bytes
“ƲÞIȥ’Ḥ

Prints the numbers without separator, i.e., the integer \$4815162342\$.
Try it online!
How it works
“ƲÞIȥ’ is bijective base-250 integer literal.
Ʋ, Þ, I, and ȥ have (1-based) indices \$154\$, \$21\$, \$74\$, and \$171\$ in Jelly's code page, so they encode the integer \$250^3\cdot154+250^2\cdot21+250\cdot74+171=2407581171\$.
Finally, Ḥ (unhalve) doubles the integer, yielding \$2\cdot2407581171=4815162342\$.
Doubling is necessary, because encoding the output directly leads to “¡9)Ƙ[’, which contains a digit.

Neim, 6 5 bytes, 3 2.5 points
Jσς§A

Explanation:
J     Push 48
 σ    Push 15
  ς   Push 16
   §  Push 23
    A Push 42
      Implicitly join the contents
      of the stack together and print

Try it online!

Python 3, 25 bytes, 12.5 points
print(*map(ord,'ዏٗ*'))

Try it online!
（髒, ⿰馬葬）, （謚, ⿰言⿱⿵八一皿） cost 4 bytes, but U+0657 only cost 2 bytes...

Python 3, 29 bytes, 14.5 points
print(ord('')*ord('湡'))

Try it online!
 （⿰馬葬） is variant character of 髒 which means "dirty". 湡 is the name of a river. And they are nothing related to this question as I known.

I asked about separator rules and we can use any individual separator which makes 4815 162342 valid. Thus print(*map(ord,'ዏ')) saves 1.5 points :) (print(*map(ord,'밗')) would save 2 points but has been specified as invalid).

05AB1E, score: 10 9 7 bytes / 2 = 3.5
•‘o]Ê•·

Try it online.
Or 7 bytes alternative:
•’µ[%•R

Try it online.
Both outputting the integer 4815162342.
Explanation:
•‘o]Ê•     # Compressed integer 2407581171
      ·    # Doubled

•’µ[%•     # Compressed integer 2432615184
      R    # Reversed

See this 05AB1E tip of mine (section How to compress large integers?) to understand why •‘o]Ê• is 2407581171 and •’µ[%• is 2432615184.

Old 9 bytes answer outputting the list [4,8,15,16,23,42]:
•ΓƒÇ²•т;в

-1 byte (and therefore -0.5 score) thanks to @Emigna.
Longer than the other 05AB1E answer, but this outputs the list [4,8,15,16,23,42] instead of the integer 4815162342.
Try it online.
Explanation:
•ΓƒÇ²•       # Compressed integer 1301916192
      т;     # Integer 50 (100 halved)
        в    # Convert the first integer to Base-50 (arbitrary): [4,8,15,16,23,42]

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress integer-lists?) to understand why •ΓƒÇ²• is 1301916192, and •ΓƒÇ²•50в is [4,8,15,16,23,42].

You could have •ΓƒÇ²•т;в for 4.5 as post-script numbers are okay for the bonus.

JavaScript (ES7), 34/2 = 17 bytes
_=>eval(atob`NjUwNTgxMDErNDEqKjY`)

Try it online!
This decodes and evaluates the expression "65058101+41**6", which does not contain any digit once encoded in base-64.
$$65058101+41^6=65058101+4750104241=4815162342$$

JavaScript (ES6), 13 bytes
Boring obvious solution.
_=>4815162342

Try it online!

Brain-Flak, 52/2 == 26 bytes
(((((((((()()()())){})){}[()])())[]()()())){}[[]]())

Try it online!

Java 8, score: 12 11.9 (70% of 17 bytes)
v->767*6277917L+3

-0.1 score thanks to @RickHitchcock.
Try it online.
Explanation:
v->               // Method with empty unused parameter and long return-type
  767             //  767
     *6277917L    //  multiplied by 6277917 (as long)
              +3  //  And then 3 is added

Old answer with a score of: 12 (50% of 24 bytes):
v->(long)''*'Ⓥ'*'䧶'

Contains an unprintable character 0x1B.
Try it online.
Explanation:
v->                   // Method with empty unused parameter and long return-type
  (long)              //  Cast the character (and therefore the result) to a long
        ''            //  27
           *'Ⓥ'       //  Multiplied by 9419
                *'䧶'  //  Multiplied by 18934

In Java, characters can be autoboxed to integers holding their unicode value. Unfortunately, the maximum supported unicode for characters is 65,535, so I can't use just two characters to multiply (since the largest two numbers that divide the expected 4,815,162,342 are 56,802 and 84,771, where the 84,771 unfortunately exceeds the maximum 65,535.
In addition, since the maximum size of an int is 322-1 (2,147,483,647) and the result 4,815,162,342 is larger than that, an explicit cast to long, which can hold up to 642-1 (9,223,372,036,854,775,807), is required.

Boring answer would have been 14 bytes without any bonuses:
v->4815162341L

Try it online.

I like this one. Pretty short for being Java :)

@Emigna Thanks. It's too bad it requires the cast to long and doesn't support very large unicode characters. If it weren't for those two restrictions mentioned, just v->''*'湡' (15 bytes, score 7.5) would have been enough. But it's still very short indeed. :) Although Java mostly has many, many weaknesses in terms of codegolfing (duhh..), calculating with characters because we aren't allowed to use digits is one of its few strengths. Was also pretty useful in this rather similar answer of mine.

11.9 bytes:  v->767*6277917L+3

@RickHitchcock It's not every day we see a 0.1 byte saving. ;)

@RickHitchcock Thanks! And I agree with Arnauld's comment above. :D

Every little bit counts. ;)

R, 18x0.7 = 12.6 score
cat(9*2*267509019)

Fairly self explanatory, just does some arithmetic avoiding the numbers in question.

7, 10 bytes, 27 characters
115160723426754314105574033

Try it online!
The packed representation of this program on disk is (xxd format):
00000000: 269c 3a71 6f63 308b 7c0d                 &.:qoc0.|.

Explanation
We've seen this sequence of numbers before, in Automate Saving the World, which was about printing the numbers at regular intervals, making it interesting via requiring the use of a very old language. Much newer languages can have their own twists that make this challenge interesting, though. (Yes, this paragraph, and in fact the reason I started writing this answer, is effectively just a way to get all the related challenges to show up together in the sidebar; normally people do that using comments but I don't have enough rep.)
The first thing to note is that 7 is made entirely of digits, so going for the bonuses here is unlikely to work (although if you view the program as a sequence of octets, none of them correspond to ASCII representations of any of the original numbers, so you could claim the bonus in that sense). The next thing to note is that 7 has commands to recreate the command sequence likely to have produced a specific piece of data; so could we possibly interpret the Lost numbers 4815162342 as a section of a 7 program itself?
The answer is "not quite". The most problematic part is that second number, 8. 7 programs are written in octal; there's no such number as 8. So the very start of the string will have to be printed differently.
The base of the program is therefore based on the 7 "Hello world" program:
5431410557403
543141055          string literal
         7         separate data from code
          4        rearrange stack: {program's source}, empty element, {literal}
           0       escape {the literal}, appending it to {the empty element}
            3      output {the escaped literal}, pop {the program's source}

with the escaped literal being in a domain-specific language that's interpreted as follows:
5                  output format: US-TTY using pairs of digits in the string
 43                select character set: digits and common symbols
   14              "4"
     10            "8"
       55          forget the set output format

After this comes an extra 3, which outputs the remaining stack element (and exits due to insufficient remaining stack). That element is specified at the start of the program, and to avoid the unmatched 6 (which works a bit like a closing bracket), we generate it using code, rather than writing it directly as data. (Note that there are two implied 7 characters at the start of the program, which is relevant here):
{77}115160723426
 7                 empty stack element
  7 11516          append "1151"
         0         append "6"
          723246   append "2324"

That produces the following literal:
115162324
1                  set output format: literally as octal
 15162324          "15162324"

which gets printed out.

It feels weird that you've got no reputation, despite posting some pretty good answers. I've read your reasoning behind posting only community answers, and I fully support you in that, but it must get annoying sometimes to not be able to comment :(

@JoKing: Well, it inspired me to actually post an answer to this question, and it turned out to be much more interesting than I expected. So I guess this is more evidence for my hypothesis that if you aren't seeking reputation, your contributions end up more beneficial for the site than otherwise. (Actually, the major frustration I have with being permanently stuck at 11 reputation is that I can't suggest edits on Meta, meaning that if I see misinformation there, I have no way to correct it.)

05AB1E, 6*0.7 = 4.2 bytes
•1Z&ð“

Try it online!
Prints the number uncompressed from base-255

You beat me to it. ;)

MASM 8088 Assembly source, (93 bytes - 50%) = 46.5 bytes
Using no numbers or the sequence in the source:
MOV AH,'P'-'G'
LEA DX,L
INT '!'
RET
T EQU '-'-'+'
L DW 'ph'/T,'jb'/T,'lb'/T,'fd'/T,'dh'/T,'$'

Output:
A>LOST.COM
4815162342

Charcoal, 13 bytes / 2 = 6.5
ＩＥTPIHA.⁻⁸⁸℅ι

Try it online! Link is to verbose version of code. Works by subtracting the ASCII codes of the string TPIHA. from 88 and casting to string.

Aheui (esotope), 45 bytes(15 chars) * 0.5 = 22.5 points
반밤밪박밭빠따받발따밣뱣히망어

Try it online!

Explanation:
See this also; Aheui Reference(English)
Aheui program starts with default stack '아'(or none)

반: push 2, move cursor right by 1(→).
밤: push 4, →
밪: push 3, →
박: push 2, →
밭: push 4, →
빠: dup, →
따: pop 2, push mul result(16).
받: push 3, →
발: push 5, →
따: pop 2, push mul result(15).
밣: push 8, →
뱣: push 4, move cursor right by 2(→→).
히: end.
망: pop 1, print, → (if stack is empty, move cursor left by 1.)
어: move cursor left by 1(←).

Note that ㅁ(print instruction) moves cursor by reverse direction if stack(or queue) is empty.

Perl 5, 16 bytes - 30% = 11.2
say 0x5FAB2EA2*3

Try it online!

PowerShell, 12 bytes * 0.7 = 8.4
0x5FAB2EA2*3

Try it online!
"Port" of Xcali's answer to have a better Powershell answer.

W j, 7 / 2 = 3.5 points
I updated the ord to support W's own code page.
0“„√*"C

Explanation
0“„√*"  % Define a string
      C % Convert to codepoints [48,15,16,23,42]

Flag:j  % Join the output list without a separator
```

naz, 46 bytes, score 32.2
2a2a1o2m1o7s1o5m1o2s2s1o6m1o2s2s1o1a1o1a1o2s1o

Simply outputs each digit in 4815162342 one at a time.

MAWP, 24 bytes
4!:2W!:2W!1A!::7M!:2W4A:

Try it!

Your 1000 rep! Nice

JavaScript, 143 bytes (not sure how to score)
(g=`${2*2}`)=>g.repeat(6).replace(/(.)/g,(m,p,i,k='')=>
  (k=m*[g-3,g-2,g,g,+g+2,g*3-1][i]
  ,RegExp(`${g-2}|${g}`).test(i)?k-1:i==+g+1?k-(g/2):k))

Try it online!
Start with six 4's, multiply, add, subtract by, to, from 4 to derive output.

Ok, you were trying to get the bonus, but with a code this size, it didn't compensate.
Why not simply '4815162342'?

@EduardoHoefel Do not gather the "score" or "bonus" system, did not try to get the bonus, just tried to not use any of the numbers required at output. The code outputs the numbers without hardcoding any of the numbers. The number 4, with addition, subtraction, multiplication and the index of the number 4 within a string (or array) can be used to derive the required numbers.

Your score is 143*0.7=100.1

JavaScript (SpiderMonkey), 67 bytes / 2 = 33.5 60 bytes / 2 = 30 58 bytes / 2 = 29 48 bytes / 2 = 24
-7 bytes/3.5, -2 bytes/1 courtesy of @JoKing, -10 bytes/5 courtesy of @tsh
print(a=-~-~-~-~[],a+=a,b=a+~-a,a+a,a+b,--b+b+b)

Try it online!

print(a=-~-~-~-~[],a+=a,b=a+~-a,a+a,a+b,--b+b+b)

Or just print(4815162342) for 17 bytes

PHP, 35/2=17.5
<?=zzzzzzzzzzzzzzz^NVBVKOVKLVHIVNH;

a digital approach: 40*.7=28
<?=2+2,_,5+3,_,17-2,_,17-1,_,17+6,_,7*6;

no digits, no strings: 68/2 = 34
<?=$p++,!$p++,$p+=$p,_,$p+=$p,_,~-$q=$p+$p,_,$q,_,--$p+$q,_,$p*~-$p;

Try them online.

Or just 14 bytes for <?=4815162342;

OP hasn´t replied to wether we can omit the delimiters or not; but yeah. Why not just 10 bytes: 4815162342. Or <?=~ + 10 unprintables -> 15/2=7.5

Japt, 10 9 bytes / 2 = 4.5
"0¢*"mc

Test it

APL(Dyalog Unicode), 18/2 = 9 bytes
×/⎕UCS'湡'

Just boring old character multiplication.
Try it online!

Whitespace, score: 49 41 bytes / 2 = 20.5
[S S S T    S S S T T   T   T   T   S S S S S S S T T   S S S T S T T   T   T   T   S S T   T   S N
_Push_4815162342][T N
S T _Print_number]

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).
Pseudo-code:
Integer i = 4815162342
Print i as number to STDOUT

Explanation:
In whitespace, a number is pushed as follows:

S: Enable Stack Manipulation
S: Push number
S/T: Positive/negative respectively
Some T/S followed by a single N: Decimal as binary, where T is 1 and S is 0

After that it is simply printed with TNST:

TN: Enable I/O
S: Output the top of the stack
T: As number

Is just pushing the number itself longer than having the extra multiply and push integer instructions?

@JoKing I usually use the vii5ard online Whitespace compiler, since it has highlighting and showing the commands at the left. But apparently it works similar as Java integers in that the maximum is 32-bits, and it wraps around to the negative above that.. So the number was too big to be pushed in one go. When I push the number in TIO it works fine though, I now realize.

Pyke, 3 points
77 91 f8 86 98 06

Try it here!
The first byte signals to read in base 128 until a byte without the high bit is set.
Finally, 32 is subtracted from the result (for historical reasons).
This allows for the generation of large numbers in very small amounts of space

JavaScript (ES6), 16 * 0.7 = 11.2 bytes
_=>767*6277917+3

Outputs the digits with no delimiters.
Try It Online!

F#, 45 bytes = 22.5 points
Just a run-of-the-mill for loop that prints the digits:
for c in"DHOPWj"do printf"%d"(int c-int '@')

The above is a complete program that can be compiled into an executable.
In a REPL (read-eval-print loop), e.g. FSI (F# Interactive), the following shorter version will work, as the REPL will output a representation of the expression evaluated; it has 35 bytes = 17.5 points:
[for c in"DHOPWj"->int c-int '@'];;

Python 3, 44 38 19 18.5 bytes
-6 bytes thanks to @Jo King
-50% bytes thanks to @ouflak for pointing out the 50% bonus
-1 byte thanks to @Dennis
for i in'밗ɯ*':print(ord(i),end='')

Try it online!

MathGolf, 7 bytes * 0.5 = 3.5
ÿ≤┼ÇÅ$∞

Try it online!
Explanation
Note that this code doesn't yet work on TIO. I have made some changes to MathGolf recently, including adding the $ operator. Once it gets pulled to TIO you can run it there, I'll make an update to this answer then. It runs perfectly in the terminal
ÿ≤┼ÇÅ     Push "≤┼ÇÅ"
     $    pop(a), push ord(a) (pushes 2407581171)
      ∞   pop a, push 2*a

I utilize the fact that MathGolf has 1-byte literals for creating strings of up to length 4. If I wanted to convert the entire number from a base-256 string, I would have needed to use two ", and the string would have been 5 characters. This way, I save 2 bytes, but I lose one byte by having the doubling operator in the end.

Python 3 34 Points
b=len("  ");c=b*b;d=c*b;e=d*b;g=e+d-b//b;print(c,d,e-b//b,e,g,g*b-c)

C# (.NET Core), 17 bytes *.7 = 11.9 bytes.
Ascii-Only's version.

()=>0x5FAB2EA2l*3

Try it online!
C# (.NET Core), 42 bytes, score = 42/2 = 21
Uses the F386 and BC17 characters.
()=>{return $"{(int)'밗'}{(int)''}";};

Try it online!

17 (*.7)

Befunge-98 (FBBI), 15 bytes / 2 = 7.5 points
"*H/!k-"*.*+..@

Try it online!
Explanation:
First push the ASCII values of the characters '*+H/!k- (42, 72, 47, 33, 107, 45) in this order to the stack. Then compute \$4815 = 45 \cdot 107\$ and \$1623 = 33\cdot 47+72\$, and output.

Runic Enchantments, 15/2 = 7.5
\>`*`
Rn$!;

Try it online!
Simply encodes the values in as few bytes as possible. 42, 16, 15, 8, and 4, coerces them to numerical values, and prints them in reverse order. 4 8 15 16 42 without any spaces, as 48151642 was an acceptable output format.
4 and 8 could not be combined (48) as that is a numerical 0 and was not allowed to be used. It is possible to combine the 15, 16, and 42 into 2 characters (instead of 3) ʂ at the expense of +1 byte, which wasn't worth it.

Intcode, 33 bytes
4,0,104,8,104,16,104,23,104,42,99

Basic hardcoded answer (104 means "output the number after this in the sequence"). Getting the bonus would be very hard (although probably possible), given that 4 is the output instruction ...

Keg, 8 - 50% = 4 bytes
밗..

Try it online!
Answer History
10 - 50% = 5 bytes

Try it online!
Literally just prints the number 4815162342 using the push'n'print method.

밗.. isn't 4 bytes is it?

@Adám, it's 4 bytes after the bonus is applied.

the old answer certainly was not eligible for either bonus

@thejonymyster it was - those aren't classified as digits by the challenge

@lyxal oh wow ok no yeah ive just never seen those unicode symbols before, i really thought it was regular ascii numbers with commas after then

Python 2, 16 bytes
print 4815162342

Try it online!

Red, 50 bytes / 2 = 25
foreach c"abcdcefgaf"[prin index? find"cfgade.b"c]

Try it online!
Prints the numbers without separator

perl -M5.010 -Mre=eval, 32/2 == 16 bytes
This program is mostly unprintable characters -- characters which aren't even Unicode characters. Here is a hexdump of the program:
$ od -x solution
0000000      2727    7e3d    277e    c0d7    8c84    869e    cbd8    c7d3
0000020      ced3    d3ca    c9ce    cdd3    d3cc    cdcb    82d8    27d6
0000040
$

And here's the program to create the solution:
#!/opt/perl/bin/perl

use 5.026;

use strict;
use warnings;
no  warnings 'syntax';

use experimental 'signatures';

my $q = ~"(?{say'4,8,15,16,23,42'})";
print "''=~~'$q'";

__END__

Z80Golf, 17 bytes * 0.5 = 8.5
00000000: 1b17 1e1a 1e19 1d1c 1b1d 2676 0a03 c5ee  ..........&v....
00000010: 2f                                       /

Try it online!
Assembly:
db 0x2F ^ '4'	;1b dec de
db 0x2F ^ '8'	;17 rla
db 0x2F ^ '1'	;1e ld e,
db 0x2F ^ '5'	;1a  0x1a
db 0x2F ^ '1'	;1e ld e,
db 0x2F ^ '6'	;19  0x19
db 0x2F ^ '2'	;1d dec e
db 0x2F ^ '3'	;1c inc e
db 0x2F ^ '4'	;1b dec de
db 0x2F ^ '2'	;1d dec e
ld h, 0x76	;halt

ld a, (bc)	;load the next digit. The first char in addr in 0x0
inc bc		;get next digit
push bc		;return to the next digit which is basically a nop
xor 0x2F	;decode the digit
		;fall through into putchar. Putchar (0x8000), prints the char in register a

Assembly

Wolfram Language (Mathematica), 68 bytes (score 34)
#&@@@"distinctive pattern nothing is known about"~StringPosition~"t"

Try it online!
Prints the list {4,8,15,16,23,42}.

T-SQL, 20 bytes - 30% bonus = 14
PRINT 2.*9*267509019

Contains none of the sequence directly. Factored via this web site. The period is in there as an implicit conversion to float so we don't overflow an INT.
This is just slightly better that the trivial solution (16 bytes, no bonus):
PRINT 4815162342

Perl 6, 17 bytes * 0.5 = 8.5
say ords "*"

Try it online!
This gets the ordinal values of a lot of unprintables and gets the no digits bonus. Using the no numbers from the sequence bonus, we can get 16 * 0.7 = 11.2 points:
say 0x5FAB2EA2*3

Try it online!
Which in turn beats the plain solution of 14 bytes:
say 4815162342

Try it online!

Python 2, 38 * 0.5 = 19 score 34 bytes * 0.5 = 17 score
print map(`int`.find,"ent t'ypey")

Try it online!
Outputs a list of the digits in the sequence; i.e. the list [4, 8, 1, 5, 1, 6, 2, 3, 4, 2].
Because it's more interesting to satisfy the 'no digits' approach, regardless of the score.
Python 2, 23 bytes - 30% = 16.1 score
print int('27mtn1i',36)

Try it online!

Lua, 69 bytes / 2 = 34.5 points
a={"","","","","","*"}s=" "for i=#s,#a do print(s.byte(a[i]))end

Try it online!

Powershell, 10 bytes, score 10
4815162342

SmileBASIC, 13 - 30% = 9.1 bytes
?&h1CB35ACA;2

Uses a hexadecimal number to avoid any of the numbers in the sequence. The final 2 needs to be printed separately because 4815162342 doesn't fit into a 32 bit signed integer.

brainfuck, 55 bytes
-[>+<-----]>+.++++.-------.++++.----.+++++.----.+.+.--.

Try it online!

I assume you used brainfuck constants, correct me if I am wrong. Please calculate your score and add it to your answer.

Gol><>, 12 bytes, score 6
"*"lRn;

Pretty simple, I just used whitespace to encode and outputted it in order, I believe the score is correct, since it said to set it to 50% if you don't use any numbers, and this only has ascii characters!
Try it online!

VBA (Excel), 38 66 bytes - 50% = 33 points
Using Immediate Window
 ?Join(Split("4 8 1 5 1 6 2 3 4 2"),"")
a="         ":For Each x in Split(a):b=b &Asc(x):Next:?b

Err! yeah you are correct. wth am I thinking. Thanks! :D

You can rearrange this to get rid of both temporary variables a and  b. For Each x in Split("         "):?Asc(x)&"";:Next --- I am not sure if it will keep the non-printing characters when I comment this, but if it does not, the string is the same as is held in a in your current version

Actually, looking at it a second time, you can drop the split entirely and iterate over the string to get it down further - 47 bytes, 23.5 points For i=1To 10:?Asc(Mid("",i))&"";:Next, where the string in the Mid statement holds the string string output by For i=1To 10:?Chr(Mid(4815162342,i,1));:Next

><>, 29/2 = 14.5 bytes
','a+'a''a'*a+:f+f+f+f+c-**n;

Forms on the stack 3 numbers 54 9419 9467, multiplies them and outputs 4815162342.
Try it online!


text:
Determine the Widest Valley
Imagine we get a slice of some mountainous region, this would result in a shape similar to this:
4                   _
3   _    _       __/ \
2  / \__/ \    _/     \_   /
1 /        \  /         \_/
0           \/
  12322223210012233343221112

As we can see, we can represent this (to a certain degree) with a sequence of integers.
For the purpose of this challenge we define a valley as a contiguous subsequence where the values initially are decreasing and from some point on they are increasing. More formally for a sequence \$(a_i)_{i=1}^n\$ a valley will be indices \$1 \leq s < r < t \leq n\$ for which the following holds:

the valley's start and endpoint are the same: \$a_s = a_t\$
the valley starts and ends once the region gets lower: \$a_s > a_{s+1} \land a_{t-1} < a_t\$
the valley is not flat: \$a_s \neq a_r \land a_r \neq a_t\$
the valley initially decreases: \$\forall i \in [s,r): a_i \geq a_{i+1}\$
the valley will at some point increase: \$\forall j \in [r,t): a_j \leq a_{j+1}\$

Now we define the width of such a valley as the size of the indices \$[s,t]\$, ie. \$t-s+1\$.
Challenge
Given a height-profile (sequence of non-negative integers), your task is to determine the width of the widest valley.
Example
Given the height-profile [1,2,3,2,2,2,2,3,2,1,0,0,1,2,2,3,3,3,4,3,2,2,1,1,1,2], we can visualize it as before:
4                   _
3   _    _       __/ \
2  / \__/ \    _/     \_   /
1 /        \  /         \_/
0           \/
  12322223210012233343221112
    aaaaaa             ccccc
         bbbbbbbbb

Note how the second valley [3,2,1,0,0,1,2,2,3] does not extend further to the right because the left-most point is \$3\$ and not \$4\$. Furthermore we don't add the remaining two \$3\$s because we require that the endpoint is higher up than the second-last point.
Therefore the width of the widest valley is \$9\$.
Rules

Input will be a sequence of non-negative (sorry Dutch people) integers

you can assume that there is always at least one valley

Output will be the size of the widest valley as defined above

Testcases
[4,0,4] -> 3
[1,0,1,0,1] -> 3
[1,0,2,0,1,2] -> 4
[13,13,13,2,2,1,0,1,14,2,13,14] -> 4
[1,2,3,2,2,2,2,3,2,1,0,0,1,2,2,3,3,3,4,3,2,2,1,1,1,2] -> 9
[3,2,0,1,0,0,1,3] -> 4

Test case: [3,2,0,1,0,0,1,3]. All current answers return 8, by your definition I believe it should be 4.

Will the slope of the mountain ever be steeper than 1? (e.g. [3,1,2,3])

@Zgarb: That's correct, yes. I added it to the testcases.

@Doorknob: There's nothing preventing that, yes. For example [4,0,4] would be such a case.

"Input will be a sequence of non-negative (sorry Dutch people) integers" Lol, as a Dutchman I giggled when I read this. ;)

Python 2, 120 115 89 87 86 152 149 bytes
lambda a:max(r-l+1for l,v in e(a)for r,w in e(a)if max(a[l+1:r]+[0])<v==w*any(s(a[l:i])[::-1]+s(a[i:r])==a[l:r]for i,_ in e(a)));e=enumerate;s=sorted

Try it online!

JavaScript (ES6), 111 108 99 97 bytes
a=>a.map(o=(p,x)=>a.some(P=q=>(~x?x<0?i?q<P:q>P&&i++:i=0:q>=p)||(o=o<--x|q==P|q-p?o:x,P=q,0)))|-o

Try it online!
Commented
a =>                        // a[] = input array
  a.map(o =                 // initialize the output o to a non-numeric value
    (p, x) =>               // for each value p at position x in a[]:
    a.some(P =              //   initialize P to a non-numeric value
      q =>                  //   for each value q in a[]:
      (                     //     exit if something goes wrong:
        ~x ?                //       if x is not equal to -1:
          x < 0 ?           //         if x is negative:
            i ?             //           if we're in the increasing part:
              q < P         //             exit if q is less than P
            :               //           else:
              q > P && i++  //             increment i if q is greater than P
          :                 //         else:
            i = 0           //           initialize i to 0 (decreasing part)
        :                   //       else:
          q >= p            //         exit if q is greater than or equal to p
      ) || (                //     if we didn't exit:
        o =                 //       update the output o:
          o < --x |         //         decrement x; if o is less than x
          q == P |          //         or the last value is equal to the previous one
          q - p ?           //         or the last value is not equal to the first one
            o               //           leave o unchanged
          :                 //         else:
            x,              //           update o to x
        P = q,              //       update the previous value P to q
        0                   //       force this iteration to succeed
      )                     //
    )                       //   end of some()
  ) | -o                    // end of map(); return -o

Jelly, 15 bytes
ẆµIṠḟ0ṢƑaMIḢ)Ṁ‘

Try it online!
Or see a test-suite (added two more test cases which I previously failed to fulfil).
How?
ẆµIṠḟ0ṢƑaMIḢ)Ṁ‘ - Link: list of integers
Ẇ               - all contiguous substrings
 µ          )   - for each substring, X:
  I             -   deltas
   Ṡ            -   sign (-ve:-1, 0:0, +ve:1)
    ḟ0          -   filter out zeros
       Ƒ        -   is invariant under:
      Ṣ         -     sort
         M      -   get maximal indices of X
        a       -   (vectorising) logical AND
          I     -   deltas
           Ḣ    -   head
             Ṁ  - maximum
              ‘ - increment

Japt, 31 bytes
¡ãYÄÃrc k_ò< Åd_äa x}Ã®bZvÃrÔ+2

Try it online!
Saved a 10 bytes by taking inspiration from Zgarb's Husk answer. I still think this can be improved, but I haven't found it yet.
Explanation:
¡ãYÄÃrc                            Get all segments
        k_           Ã             Remove ones where:
          ò<                        A non-increasing sub-segment
             Å                      Other than the first one
              d_äa x}               Has different heights
                      ®   Ã        For each remaining segment:
                       bZv          Get the second index of the first character
                           rÔ      Maximum
                             +2    Increase by 2

Retina 0.8.2, 77 bytes
\d+
$*
M&!`\b(1+),((?!\1)(?!1+\2)1*,)+((?!\1)1*(?(3)\3|\2))*\1\b
1

O^`
\G,|$

Try it online! Link includes test cases. Explanation:
\d+
$*

Convert to unary.
M&!`

List, rather than counting, overlapping matches.
\b(1+),

The valley's start is captured into \1. This must then not match again until the end. Since we don't capture the comma, this also prevents higher values from matching.
((?!\1)(?!1+\2)1*,)+

Match the decreasing values. The (?!1+\2) prevents the any pass through the loop from being greater than the previous. (The first time through \2 isn't set so it fails to match trivially.) The capture includes the trailing comma as that's golfier.
((?!\1)1*(?(3)\3|\2))*

Match the increasing values. This time ((?3)\3|\2) means that each match is required to be at least as long as the previous value, or the last decreasing capture the first time through the loop.
\1\b

Finally the end of the valley must be the same height as the start.
1

Delete the heights, leaving the commas. (This is slightly easier than counting the heights as some of them might be zero.)
O^`

Sort in reverse order i.e. most commas first.
\G,|$

Count the number of commas on the first line, plus one.

Husk, 13 bytes
→▲mΓ€fȯΛEtġ≤Q

Try it online!
Explanation
I use a similar algorithm as Jonathan Allan.
→▲mΓ€fȯΛEtġ≤Q  Input is a list, say [3,1,0,1,1,0,2,3]
            Q  Nonempty slices: [[3],[1],[3,1],[0],...,[3,1,0,1,1,0,2,3]]
     f         Keep those that satisfy this:
                Argument is a slice, say [3,1,0,1,1,0,2]
          ġ≤    Cut into non-increasing pieces: [[3,1,0],[1,1,0],[2]]
         t      Drop first piece: [[1,1,0],[2]]
      ȯΛ        Each remaining piece
        E       has all elements equal: false, [1,1,0] has different elements
  m            Map over remaining slices:
                Argument is a slice, say [1,0,1,1]
   Γ            Break into head 1 and tail [0,1,1]
    €           Index of first occurrence of head in tail: 2
 ▲             Maximum: 2
→              Increment: 3

source: Stack Exchange

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

sort: votes


text:
Toasty, Burnt, Brûlée!
It turns out that my toaster is a tad broken. It lost WiFi (You know, it's one of those newfangled smart toasters), and its been going bonkers! Since it no longer works, I've been having to hack into my breakfast's source code and run Plate.bread.toastAs(3); every morning. Will you help?
My toaster takes one input: the amount of time you want to toast your bread. This is written as min:sec, such as 5:45 or 0:40 (Up to 59:59). It then returns a specific value for different levels of toastiness:
0:00-0:30 = Bread
0:31-1:00 = Warm Bread
1:01-2:00 = Toasty
2:01-3:30 = Burnt
3:31 and up = Brûlée (or Brulee)

But here's the catch: my toaster has a broken keyboard! Your code can't contain any semicolons or...colons. This might be harder than the toaster repairman said it would be...
Here are some test cases, so you can...test your cases?
0:00 = Bread
5:50 = Brulee or Brûlée
2:00 = Toasty
ChicknMcNuggets = Anything
-1:00 = Anything
0:60 = Anything
1 = Anything
60:00 = Anything
1:00:00 = Anything

Standard Loopholes are prohibited
All Acceptable Forms of Input/Output are accepted
My Toaster's new code cannot contain a semicolon (;) or colon (:)
This is code-golf, so the shortest answer (in each language) wins!

Is the time at most 59:59?

Oh, yes. Forgot to mention that!

Shouldn't it be 3:31 and up: Brulee?

Where are all the golfing languages where colons wouldn't be used anyway?

So how to test the cases?

I have't realized until now why there aren't any Python submissions...

Can we take in input with a leading zero so that all inputs are 5 characters long?

@Quintec Hmm...no, it should work with11:05 or  1:05. Sorry.

I meant like 01:05 and 11:05 instead of 1:05- just to clarify, that’s a no, right

@Quintec Yes, since it would make the code much shorter and pose a disadvantage to those which have already been submitted (Not to mention the fact that it would no longer be a big deal that there can be no colons).

@RedwolfPrograms "I have't realized until now why there aren't any Python submissions...". Why? :-)

@ElPedro Colons

@RedwolfPrograms. I know and that's why I put the smile on the end of my comment. It took me a while to work out how to avoid colons. For me that was what was the most interesting part about what what a good challenge anyway :)

Is the input suggested in this comment acceptable? The input is literally 6:00 but that is evaluated by R to the vector [6, 5, 4, 3, 2, 1, 0].

Python 2, 124  118 116
t=eval(input().replace("\x3A","."))
print["Bread","Warm Bread","Toasty","Burnt","Brulee"][sum([t>3.3,t>2,t>1,t>.3])]

Try it online!
-6 with thanks to @tsh and also thanks for tho TIO test cases.
-2 with a couple of cool tips from @BlackOwlKai
Throws a ValueError for invalid inputs that cannot be converted to a float. For numbers less than 0 it returns "Bread" because it is still bread. Guess if we are really strict on ensuring that the input is a valid time it could be done but for me the interesting bit was how to avoid the : in Python.

118 bytes

@tsh Thanks for the neat trick and thanks also for the TIO tests.

-1 byte by replacing float by eval

Thanks @BlackOwlKai. Hadn't seen that. Will update tomorrow with appropriate credits ☺

-1 byte because chr(58) can be shortened to "\x3A"

Thanks @BlackOwlKai. Back on the laptop now so posted your tips. Thanks again.

T-SQL, 409 379 328 318 bytes
DECLARE @i varchar(9)DECLARE @a time='0'+CHAR(58)+@i DECLARE @ int=DATEPART(N,@a),@s int=DATEPART(S,@a)SELECT CASE WHEN @<1AND @s<31THEN'Bread'WHEN @<1OR @=1AND @s=0THEN'Warm Bread'WHEN @<2OR @=2AND @s=0THEN'Toasty'WHEN @<3OR @<4AND @s<31THEN'Burnt'ELSE'Brulee'END WHERE LEN(RIGHT(@i,LEN(@i)-CHARINDEX(CHAR(58),@i)))=2

-30 bytes: removed AS keywords, combined DECLARE statements (thanks to BradC)
-51 bytes: changed declarations/where clause to take advantage of SQL's datetime functionality
-10 bytes: changed MINUTE to N and SECOND to S (thanks to BradC)
Did you know that SQL can't natively split strings in any decent capacity? Don't let STRING_SPLIT fool you; it doesn't work for this. Or at least, I'm not smart enough to figure it out.
Different from BradC's table-based T-SQL solution.
Ungolfed:
-- Input variable
DECLARE @i varchar(9)

-- Time declarations (passes in as form "00:mm:ss")
-- CHAR(58) maps to ':'
DECLARE @a time = '0' + CHAR(58) + @i

-- Integer declarations
DECLARE @ int = DATEPART(N, @a),    -- minutes
        @s int = DATEPART(S, @a)    -- seconds

SELECT CASE
            WHEN @ < 1 AND @x < 31              -- 0:00 - 0:30
                THEN 'Bread'
            WHEN @ < 1 OR @ = 1 AND @x = 0      -- 0:31 - 1:00
                THEN 'Warm Bread'
            WHEN @ < 2 OR @ = 2 AND @x = 0      -- 1:01 - 2:00
                THEN 'Toasty'
            WHEN @ < 3 OR @ < 4 AND @x < 31     -- 2:01 - 3:30
                THEN 'Burnt'
            ELSE 'Brulee'                       -- 3:31 - 59:59
       END

-- Setting input as a time means that you only have to check if the seconds input is two characters, all other checks accounted for
WHERE LEN(RIGHT(@i, LEN(@i) - CHARINDEX(CHAR(58), @i))) = 2

You could do something like SELECT value FROM STRING_SPLIT(@i,CHAR(58)), although I'm wondering if a TRY_CAST(@i AS TIME) might cut some corners.

Interesting language for golfing!

@BradC I tried doing STRING_SPLIT like that, but it doesn't exactly work as you'd think - it actually returns both values from each side simultaneously, and you can't do any checks on the data (at least that I could figure out). As for using TRY_CAST, it looks like it would require having "00:" appended to the front. I might be able to work further with that.

Yeah, STRING_SPLIT returns them as separate rows. Even without changing those parts, you can still save a ton of bytes by keeping only your very first DECLARE and changing the rest to commas. Also drop AS and just do DECLARE @i varchar(99),@a varchar(9)=...

Yeah, good call. Since @a and @b both require @i though, I have to declare that separately. Can still save quite a few bytes there though.

Nice improvements! Save a few more by using n for MINUTE and s for SECOND in your DATEPART() functions: DATEPART reference

I knew there was a smaller way to write those. Thanks!

Java 8, 148 bytes
a lambda from String to String
t->{float n=new Float(t.replace("\72","."))\u003breturn n>3.3?"Brulee"\u003an>2?"Burnt"\u003an>1?"Toasty"\u003an>.3?"Warm Bread"\u003a"Bread"\u003b}

\u003b and \u003a are source-level Unicode escape sequences for ; and : respectively.
Try It Online
Ungolfed
t -> {
    float n = new Float(t.replace("\72",".")) \u003b
    return
        n > 3.3 ? "Brulee" \u003a
            n > 2 ? "Burnt" \u003a
            n > 1 ? "Toasty" \u003a
            n > .3 ? "Warm Bread" \u003a
            "Bread"
    \u003b
}

Acknowledgments

-24 bytes thanks to Olivier Grégoire

.replaceAll can be .replace and Integer.parseInt can be new Integer, or new Short even, to save 10 bytes: Try it online 162 bytes.

148 bytes by changing the split to a simple ternary operator and using a float instead of an int to spare on the "hundreds" bytes.

Nice. Thanks guys!

JavaScript (SpiderMonkey), 100 bytes
a=>'Bread,Warm Bread,Toasty,Burnt,Brulee'.split`,`[((t=a.replace(/\D/,'.'))>3.3)+(t>2)+(t>1)+(t>.3)]

Try it online!

JavaScript (Node.js), 91 bytes
a=>[,b='Bread','Warm '+b,o='Toasty',o,u='Burnt',u,u][new Date([70,a])/-~18e5+1|0]||'Brulee'

Try it online!

T-SQL, 143 155 145 bytes
SELECT TOP 1b FROM i,
(VALUES(31,'Bread'),(61,'Warm Bread'),(121,'Toasty'),(211,'Burnt'),(1E4,'Brulee'))t(a,b)
WHERE a>DATEDIFF(s,0,'0'+CHAR(58)+v)

Line breaks are for readability only. Different method than Meerkat's variable-based SQL solution.
Input is taken via pre-existing table i with varchar field v, per our IO standards. That input table is cross-joined to an in-memory table t with our cutoff values (in seconds) and the desired labels.
The magic happens in the WHERE clause: DATEDIFF calculates the difference in seconds between midnight and our input (with an extra 0: attached to the front), then returns the lowest matching label (via the TOP 1).
Invalid inputs either return an unpredictable value or throw an error: Conversion failed when converting date and/or time from character string.
The question was a little vague, but if needed I can avoid these errors (and return nothing) by adding the following LIKE pattern to the WHERE clause, bringing the total bytes to 238 211 201:
AND RIGHT('0'+v,5)LIKE'[0-5][0-9]'+CHAR(58)+'[0-5][0-9]'

EDIT: My original shorter submission was failing for inputs over 24:00, since I was treating it as hh:mm. Had to add the '0'+CHAR(58)+ prefix, which added 12 bytes.
EDIT 2: Shaved 27 bytes from the LIKE in my alternate version
EDIT 3: Removed ORDER BY from both versions, as it proved unnecessary in testing. (SQL doesn't guarantee sort order will be maintained without an explicit ORDER BY, but it seemed to work fine for me in this specific case.)

PHP, 96 bytes
<?=[Bread,"Warm Bread",$t=Toasty,$t,$u=Burnt,$u,$u,Brulee][min(7,2*$argn+substr($argn,-2)/30)]?>

requires PHP 5.5 or later. Run as pipe with -nF or try it online.

05AB1E, 43 42 bytes
þ30тx330)ć‹O„©Ãº™D#θ‚R.•liSÕô6>Āµ·•6ôÀ«™sè

Try it online or verify some more test cases.
Explanation:
þ                # Leave only the digits of the (implicit) input
                 #  i.e. "1:15" → 115
 30              # Push 30
   т             # Push 100
    x            # Pop and push 100 and 100 doubled (200)
     330         # Push 330
        )        # Wrap the stack into a list: [inputDigits,30,100,200,330]
         ć       # Pop and push the head and rest of array as separated items to the stack
          ‹      # Check for each if its smaller than the head (1=truthy, 0=falsey)
                 #  i.e. [30,100,200,330] and 115 → [1,1,0,0]
           O     # Take the sum of this
                 #  i.e. [1,1,0,0] → 2
„©Ãº™            # Push string "warm bread"
     D#          # Duplicate it, and split it by spaces: ["warm","bread"]
       θ         # And only leave the last element: "bread"
        ‚R       # Pair them into a list, and reverse that list: ["bread","warm bread"]
.•liSÕô6>Āµ·•    # Push string "bruleetoastyburnt"
             6ô  # Split into parts of size 6: ["brulee","toasty","burnt"]
               À # Rotate it once towards the left: ["toasty","burnt", "brulee"]
«                # Merge both lists together:
                 #  ["bread","warm bread","toasty","burnt","brulee"]
 ™               # Titlecase each word: ["Bread","Warm Bread","Toasty","Burnt","Brulee"]
  s              # Swap so the number is at the top of the stack again
   è             # Index it into the list (and output implicitly)
                 #  i.e. 2 → "Toasty"

See this 05AB1E tip of mine (sections How to use the dictionary? and How to compress strings not part of the dictionary?) to understand why „©Ãº™ is "warm bread" and .•liSÕô6>Āµ·• is "bruleetoastyburnt".
þ30тx330)ć can alternatively be 30тx)DOªsþ for the same byte-count: Try it online.

Javascript(ES6+), 180 bytes
Node.js(180 bytes)
let f=(s,i=s.split("\u{3a}"),j=i[0]*60+1*i[1],k="Bread",l=assert(new RegExp("^(.|[0-5].)\u{3a}[0-5].$").test(s)))=>eval("(j<31)?k\u{3a}(j<61)?'Warm '+k\u{3a}(j<121)?'Toasty'\u{3a}(j<211)?'Burnt'\u{3a}'Brulee'")

Browser(188 bytes):
let f=(s,i=s.split("\u{3a}"),j=i[0]*60+1*i[1],k="Bread",l=console.assert(new RegExp("^(.|[0-5].)\u{3a}[0-5].$").test(s)))=>eval("(j<31)?k\u{3a}(j<61)?'Warm '+k\u{3a}(j<121)?'Toasty'\u{3a}(j<211)?'Burnt'\u{3a}'Brulee'")

Gotta use those unicode escape sequences :-) just a big chain of ternary operators, with variables defined by default parameters. Also a one-liner, so no semicolon-hungry js

I used a regex to enforce the 59:59 & no negatives rule :-)

OH WAIT I forgot i added :

actually done :-)

You don't need a regex to enforce the 59:59 and no negatives...they can result in anything, be it an error, nothing, or Brulee.

Perl 6, 86 79 67 bytes
-4 bytes thanks to nwellnhof! -12 bytes by porting tsh's solution
{<<Bread'Warm Bread'Toasty Burnt Brulee>>[sum S/\D/./X>.3,1,2,3.3]}

Try it online!

Retina 0.8.2, 97 bytes
.+(..)
$*1#$1$*
+`1#
#60$*
#1{211,}
Brulee
#1{121,}
Burnt
#1{61,}
Toasty
#1{31,}
Warm #
#1*
Bread

Try it online! Link includes test cases. Explantion:
.+(..)
$*1#$1$*

Convert the minutes and seconds to unary.
+`1#
#60$*

Multiply the minutes by 60 and add to the seconds.
#1{211,}
Brulee
#1{121,}
Burnt
#1{61,}
Toasty

Decode the seconds into the toastiness.
#1{31,}
Warm #

Decode Warm Bread by noting that # (for 0:00) decodes to Bread.
#1*
Bread

If we don't have a toastiness yet then the bread is still cold.

C (gcc), 130 bytes
f(a){if(*strchr(a,58)=48,a=atoi(a),a=(int*[]){"Bread","Warm Bread","Toasty","Burnt","Brulee"}[(a>30)+(a>1e3)+(a>2e3)+(a>3030)]){}}

Try it online!

Japt, 48 bytes
`BÎ%
W‡m BÎ%
To†ty
B¨›
BrÔ‡`·g[30LLÑ,330]è<Ur58d

Try it online!
Saved 5 bytes by actually reading the tips...
Explanation:
`BÎ%...BrÔ‡`·                       Compressed array of possible outputs
             g                      Get the one at the index given by...
                         è          The number of items...
              [30LLÑ,330]           From the list [30,100,200,330]...
                          <Ur58d    Which are less than the input without ":"

An extra byte could be saved by outputting in all lower case.

46 if lower case allowed

47 if not

@LuisfelipeDejesusMunoz both of those contain a colon, which isn't allowed by the challenge. LÑ saves a byte though, and I didn't think about whether all lowercase is allowed.

Snap! 4.2, 257 251 bytes
Minified the text version some more.
I haven't found any answers in Snap!, a visual programming language similar to Scratch, so I'll use scratchblocks2 syntax, pretending that Snap! exclusive blocks are valid in scratchblocks2.
Try it online! (click the button with the two arrows to see the code)
when gf clicked
ask[]and wait
set[l v]to(split(answer)by(unicode(58)as letter
set [t v]to(((item(1 v)of(l))*(60))+(item(2 v)of(l
if<(t)<[31
say[Bread
else
if<(t)<[61
say[Warm Bread
else
if<(t)<[121
say[Toasty
else
if<(t)<[211
say[Burnt
else
say[Brulee

R, 127 122 bytes
function(t)cut((x=eval(parse(t=t)))[1]*60+tail(x,1),30*c(0:2,4,7,Inf),c("Bread","Warm Bread","Toasty","Burnt","Brulee"),T)

Try it online!
Returns a factor with the appropriate level.
-5 bytes thanks to JayCe.

Would this work? https://tio.run/##NYi9CoMwEIBfRTLd2StcFDKUTm7dhQ7FIcQEBBvhvAw@faxDp@9Hamqe95pKDrpsGRRDUdCPnVrHN/XLCkoWKQBTz@SYbMfUWaZXTtc2g0Q/GzJvL9/mH@Pmdz1@MhTJelHKGqNBGrEmcA9mrCc

@JayCe IDK, the input is "any acceptable format" but then everything takes the string...I'll ask in the comments.

@JayCe I'm not sure what you mean. As far as I can see, it takes the time as an input to a function which is an acceptable input IMO

And you can also do 30*c(0,1,2,4,7,Inf)

@RedwolfPrograms the input isn't a time, it's an array, : is the sequence operator.

@Giuseppe Hmm, I'd say that's a no.

Jelly, 43 41 40 bytes
fØD~~ḌH“Ð2dʠ‘<Sị“¡Ḳḋ\ḞvṾƤSİƓƥeF½ÞØ+®°»Ỵ¤

Try it online!
Explanation (old)
“¡Ḳḋ\ḞvṾƤSİƓƥeF½ÞØ+®°» is the compressed string Warm Bread\nToasty\nBurnt\nBrulee\nBread, found by the compression optimizer.
fØD                               Filter out the non-digits (i.e. colon) from input
   ~~                             Use binary NOT twice to convert to digit list
     Ḍ
      HḞ                        Halve and floor. Now we have "01:45" -> 72.
        “Ç1cƥ‘                    The array [14,49,99,164]
              <                   Vectorized less than
               S                  Sum
fØD~~ḌHḞ“Ç1cƥ‘<S                How many threshold times is input less than?
                                           (0 -> Bread, 4 -> Brulee.)
                ị               Index (note 0ị gives the last list item) into
                       ¤        the new dyadic link given by
                 “...»            The long string, decoded and
                      Ỵ           split by newlines.

Inspired by Kamil Drakari's answer.
-2 bytes using snippet ~~Ḍ from Dennis.

Runic Enchantments, 118 bytes
\>`tttt`,kw,kw,kw,ki
\uqn.3X)?\ . 1C)?\.2C)?\'Ŋ)?\"Brulee"
\D"daerB"L" mraW"/
$L"ytsaoT"L?9"tnruB"L?aL?3 F/

Try it online!
Utilizes some unprinting ASCII characters (STX, EOT, SOH, STX, VT, SOH, STX, DC2, SOH, and STX in that order) on the first line, which is reading in a sequence of bytes in the order that they're going to be needed on the stack. 3 divide ('t'/2 equals :) and reflective-write operations are then performed. This puts 3 : (duplicate) commands where there are currently . (NOP) in order to non-destructively compare the input with the time thresholds. A fourth : is left on the stack before reading input.
Time is read in as a string, then split on :, and concatenated back into a string. As values above 59:59 do not have any specification on output, values like 1:00:00 will have undefined (but deterministic) output. This string is then converted to a number and compared against 30, 100, 200, and 330 (the byte value of Ŋ). "Bread" (line 3, executing RTL) is used twice, both for Bread and Warm Bread results, saving at least 5 bytes.
Saves 1 byte by not having a classic terminator command (;) by using Fizzle on the last line instead. This convinces the parser that the program is guaranteed to terminate without causing it to do so immediately (and, more importantly, not touching the stack). Valid inputs will leave the stack empty so that when it loops around and touches a w the IP is terminated for performing an illegal action.

After reading the name of this language, I for some reason have the image of a wizard chanting ASCII code points stuck in my head.

@RedwolfPrograms *GRIN* https://cdn.discordapp.com/attachments/272860530505547776/536721740437520404/clank.gif

Javascript, 115 101 bytes
-6 from tsh
d=>[b="Bread","Warm "+b,a="Toasty",a,c="Burnt",c,c][~~(parseInt(d)*1.999+d.slice(-2)/30.1)]||"Brulee"

JavaScript (ES6), 171 bytes
(x,y=Math.ceil(x.split(/\D/).reduce((a,b)=>(+a)*60+(+b))/30))=>["Bread","Bread","Warm Bread","Toasty","Toasty","Burnt","Burnt","Burnt","Brulee","Brulee","Brulee"][y>8?8:y]

Run some test cases with this Stack Snippet:

var f=(x,y=Math.ceil(x.split(/\D/).reduce((a,b)=>(+a)*60+(+b))/30))=>["Bread","Bread","Warm Bread","Toasty","Toasty","Burnt","Burnt","Burnt","Brulee","Brulee","Brulee"][y>8?8:y]

var result = document.getElementById("result");
["0:00", "0:30", "0:31", "1:00", "1:01", "2:00", "2:01", "2:30", "2:31", "3:00", "3:01", "3:30", "3:31", "4:00", "4:01", "4:30", "4:31", "5:00", "6:00"].forEach(x => result.innerHTML += `${x}: ${f(x)}\n`);

@JoKing Whoops, I missed a few possibilities while trying to save bytes. Working on a fix.

F#, 177 bytes
let t i=
 let s=i.ToString().Split(char 58)
 let m=int s.[0]*60+int s.[1]
 if m<31 then"Bread"elif m<61 then"Warm Bread"elif m<121 then"Toasty"elif m<211 then"Burnt"else"Brulee"

Try it online!
Thanks to Jo King for straightening out my, umm, needlessly literal interpretation of the challenge...
F# is fairly okay for functions without semi-colons or colons. The only real issue was that I couldn't do i.Split directly without a type annotation - F# would not have been able to deduce the type of i based on the method call. That would have required defining the type directly in the function, like let t (i:string)= which would have been against the rules.
But I could easily get by it by i.ToString(), which then allowed me to call Split on it. Then char 58 is a colon character, and after that it's straight-forward.

But that's what the requirements specification said! :P

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


text:
Generate some rough numbers
Background
A number n can be described as B-rough if all of the prime factors of n strictly exceed B.
The Challenge
Given two positive integers B and k, output the first k B-rough numbers.
Examples
Let f(B, k) be a function which returns the set containing the first k B-rough numbers.
> f(1, 10)
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

> f(2, 5)
1, 3, 5, 7, 9

> f(10, 14)
1, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59

Can you elaborate on the challenge? I don't understand it. Maybe explain the examples?

I don't understand why you include 1 in all your answers when it's never greater than B?

1 has no prime factors, so every prime factor of 1 is larger than B and 1 should appear in the output independent of B.

@d-b Factorize n into primes. If all of those primes are greater than B, n is B-rough.

@AddisonCrump So for example, since the primes for 35 are 5 and 7, 35 is 4-rough? Is this some recognized common terminology? Never heard of it before. I still don't under the examples, especially not the last one. 14 numbers but what is 10??

@d-b The terminology is a joke about B-smoothness in number theory, which is the opposite feature. I declare f as f(B, k) in the text above, so f(10, 14) is the first 14 10-rough numbers.

@AddisonCrump So basically it is the first 14 primes above 10 with the exception of 1 that is always included (13 numbers above ten and 1)? If you had set k to something high in the last example a number like 121 (11x11) would have been included even though it is not a prime in itself?

@d-b I'm not sure what your confusion is. The last one is only primes, sure, because there are more primes between 11 and 121 than 10, but that doesn't imply that the sequence strictly generates primes. This just asks you to determine the first k numbers for which each number in the sequence only has prime factors exceeding B.

How is the best answer defined

@VortexYT Shortest source code, but you should compete against your only language. You're not gonna beat Jelly with Java.

Python 3, 80, 75 bytes
lambda B,k:[i for i in range(1,-~B*k)if all(i%j for j in range(2,B+1))][:k]

Try it online!
Thanks to shooqie for saving 5 bytes.
This assumes that the k'th B-rough number will never exceed \$B * k\$, which I don't know how to prove, but seems like a fairly safe assumption (and I can't find any counterexamples).
Alternate solution:
Python 2, 78 bytes
B,k=input()
i=1
while k:
 if all(i%j for j in range(2,B+1)):print i;k-=1
 i+=1

Try it online!
This solution does not make the above solution. And is much more efficient.

Hmm, that assumption is probably verifiable, but an interesting problem nonetheless. I'll bounty for a proof.

Why not lambda B,k:[i for i in range(1,-~B*k)if all(i%j for j in range(2,B+1))][:k] ?

@BlackOwlKai That sounds cool. See also https://math.stackexchange.com/questions/2983364/bounds-on-the-size-of-rough-numbers

@Anush Sadly, my proof didn't work, because I made a mistake

Haskell, 53 44 bytes
b%k=take k[n|n<-[1..],all((>0).mod n)[2..b]]

Try it online!
Thanks to H.PWiz for -9 bytes!
b%k=                       -- given inputs b and k
 take k                    -- take the first k elements from
  [n|n<-[1..]              -- the infinite list of all n > 0
   ,all            [2..b]] -- where all numbers from 2 to b (inclusive)
      ((>0).mod n)         -- do not divide n.

This can be simplified somewhat

@H.PWiz Right, somehow I only thought about taking the (>b)-part inside the comprehension (which does not work) but not the other way around. Thanks!

Perl 6, 35 32 bytes
-3 bytes thanks to nwellnof!
{grep(*%all(2..$^b),1..*)[^$^k]}

Try it online!
An anonymous code block that takes two integers and returns a list of integers.
Explanation
{                              }  # Anonymous code block
 grep(             ,1..*)        # Filter from the positive integers
      *              # Is the number
       %             # Not divisible by
        all(      )  # All of the numbers
            2..$^b   # From 2 to b
                         [^$^k]   # And take the first k numbers

What does all do?

@AddisonCrump all checks if all the elements in the list are truthy. I will be adding an explanation for the whole thing shortly

@nwellnhof Wow! So that's what Junctions are useful for!

Yes, note that you could also use [&] instead of all.

@AddisonCrump I guess all isn't being used in that way any more, so I should update my answer. all creates a Junction of the values in the range 2..b, and any operations performed on the Junction gets performed on all the values simulataneously. When it is evaluated in Boolean context by the grep, this collapses into whether all the values in the Junction are truthy, ie non-zero

Jelly, 7 bytes
1Æf>Ạɗ#

Try it online!

Husk, 9 8 bytes
↑foΛ>⁰pN

Try it online!
Takes \$B\$ as first and \$ k \$ as second input.
↑         -- take the first k elements
       N  -- from the natural numbers
 f        -- filtered by
  o   p   -- the prime factors
   Λ>⁰    -- are all larger than the first input

Jelly, 10 bytes
1µg³!¤Ịµ⁴#

Try it online!
How it works
1µg³!¤Ịµ⁴#    Dyadic main link. Left = B, right = k
       µ⁴#    Take first k numbers satisfying...
  g             GCD with
   ³!¤          B factorial
      Ị         is insignificant (abs(x) <= 1)?
1µ            ... starting from 1.

JavaScript (ES6), 68 bytes
Takes input as (b)(k).
b=>k=>(o=[],n=1,g=d=>(d<2?o.push(n)==k:n%d&&g(d-1))||g(b,n++))(b)&&o

Try it online!
Commented
b => k => (             // input = b and k
  o = [],               // o[] = output array
  n = 1,                // n = value to test
  g = d => (            // g = recursive function, taking the divisor d
    d < 2 ?             // if d = 1:
      o.push(n) == k    //   push n into o[] and test whether o[] contains k elements
    :                   // else:
      n % d && g(d - 1) //   if d is not a divisor of n, do a recursive call with d - 1
    ) ||                // if the final result of g() is falsy,
    g(b, n++)           // do a recursive call with d = b and n + 1
)(b)                    // initial call to g() with d = b
&& o                    // return o[]

Charcoal, 33 bytes
ＮθＮη≔⁰ζＷ‹Ｌυη«≦⊕ζ¿¬Φθ∧κ¬﹪ζ⊕κ⊞υζ»Ｉυ

Try it online! Link is to verbose version of code. Explanation:
ＮθＮη

Input B and k.
≔⁰ζ

Set z to 0.
Ｗ‹Ｌυη«

Repeat until we have k values.
≦⊕ζ

Increment z.
¿¬Φθ∧κ¬﹪ζ⊕κ

Divide z by all the numbers from 2 to B and see if any remainder is zero.
⊞υζ»

If not then push z to the predefined empty list.
Ｉυ

Cast the list to string and implicitly output it.

JavaScript (Node.js), 68 bytes
b=>g=(k,i=1,j=b)=>k?j>1?i%j?g(k,i,j-1):g(k,i+1):[i,...g(k-1,i+1)]:[]

Try it online!

APL(NARS), 52 chars, 104 bytes
r←a f w;i
r←,i←1⋄→3
i+←1⋄→3×⍳∨/a≥πi⋄r←r,i
→2×⍳w>↑⍴r

Above it seems the rows after 'r←a f w;i' have names 1 2 3;test:
  o←⎕fmt
  o 1 h 2
┌2───┐
│ 1 2│
└~───┘
  o 1 h 1
┌1─┐
│ 1│
└~─┘
  o 10 h 14
┌14───────────────────────────────────────┐
│ 1 11 13 17 19 23 29 31 37 41 43 47 53 59│
└~────────────────────────────────────────┘

05AB1E, 9 bytes
∞ʒÒ¹›P}²£

Try it online or verify all test cases.
Explanation:
∞          # Infinite list starting at 1: [1,...]
 ʒ    }    # Filter it by:
  Ò        #  Get all prime factors of the current number
   ¹›      #  Check for each if they are larger than the first input
     P     #  And check if it's truthy for all of them
       ²£  # Leave only the leading amount of items equal to the second input

Ruby, 56 bytes
->b,k{(1..).lazy.reject{|n|
(2..b).any?{n%_1<1}}.take k}

Attempt This Online!


text:
Count the corners, edges and faces of a cut cube
Coming from this sandbox post
This is inspired from an 8th graders math test
Intro
We have a cube with following corners
A(0, 0, 0)
B(1, 0, 0)
C(1, 1, 0)
D(0, 1, 0)
E(0, 0, 1)
F(1, 0, 1)
G(1, 1, 1)
H(0, 1, 1)

This cube clearly has 8 corners, 12 edges and 6 faces. If we now cut off corner G, such that our cut plane goes exactly through the middle of each adjacent original edge, we add 2 new corners, 3 new edges and one new face.  Please enjoy this hand drawn piece of art, for better clarification

Input
Given a list of corners (in this example identified by A-H), that will  be cut off, compute the new number of corners, edges and faces.
You make take the input in any form you like, as long as it responds to the same corners (e.g. instead of A-H you can use 1-8 or 0-7, you can assume it to be a list, csv, whatever)
You can assume the list to be distinct (every corner will appear once at most), but it may be empty. The list will never contain non existing corners.
Output
Output three numbers corresponding to the number of corners, edges and faces. Output as a list is explicitly allowed.
Trailing whitespaces are allowed
Examples
{}        ->  8, 12,  6 (empty list)
{A}       -> 10, 15,  7
{A,C}     -> 12, 18,  8
{A,C,F}   -> 14, 21,  9
{A,B,C}   -> 12, 19,  9
{A,B,C,D} -> 12, 20, 10

Finally, this is codegolf, thus the shortest answer in bytes wins. Please refrain from standard loopholes.

Interesting... So cutting off adjacent corners will mean they share one corner, and eliminate one edge? This is more complex than it seems at first

Since imgur being blocked in Turkey, I can not see the image. Can you please send an alternate image link

@JoKing yes that is correct.

@WindmillCookies I'm sorry, I didn't know that. I've used a different host now.

Thank you, Now I am able to give the question a try

For example, may I use 0 for A, 1 for C, 2 for B, 3 for D, 4 for E, 5 for G, 6 for F, 7 for H? Or should I keep the order of ABCDEFGH?

I decided that it's okay to rearrange the order.

Jelly, 23 bytes
3R×L+“©®€‘ɓŒcn/€§ċ1;`Żạ

A monadic Link. Input is a list of corners of the cube as Cartesian co-ordinates (cube aligned with the co-ordinate system). Output is a list of integers, [faces, corners, edges].
Try it online!
How?
3R×L+“©®€‘ɓŒcn/€§ċ1;`Żạ - Link: list of lists, C          e.g. [[0,1,1],[1,1,0],[1,1,1],[0,0,0]] -- this could represent "FHGA"
3R                      - range of 3                           [1,2,3]
   L                    - length of C                          4
  ×                     - multiply                             [4,8,12]
     “©®€‘              - list of code-page indices            [6,8,12]
    +                   - add                                  [10,16,24]
          ɓ             - start a new dyadic chain, f(C,X) where X is the above result
           Œc           - pairs of C                           [[[0,1,1],[1,1,0]],[[0,1,1],[1,1,1]],[[0,1,1],[0,0,0]],[[1,1,0],[1,1,1]],[[1,1,0],[0,0,0]],[[1,1,1],[0,0,0]]]
              /€        - reduce €ach with:
             n          -   (vectorising) not equal?           [[1,0,1],[1,0,0],[0,1,1],[0,0,1],[1,1,0],[1,1,1]]
                §       - sum each                             [2,1,2,1,2,3]
                 ċ1     - count ones                           2
                   ;`   - concatenate with itself              [2,2]
                     Ż  - prepend a zero                       [0,2,2]
                      ạ - absolute difference with X           [10,14,22]

If the corners must be "ordered" as they are in the question then this works with integers 0-7 as A-H for 25 bytes: 3R×L+“©®€‘ɓŒc^/€ḟ2<5S;`Żạ (reduces using XOR, filters out twos, then counts those less than five).

Perl 6, 59 58 bytes
{6+@_,|((2,3 X*4+@_)X-(@_ X~@_)∩~<<ords "% 286
>C/")}

Try it online!
Uses the numbers 0 to 7 to represent the corners. I probably should have matched them up to the same order as in the question... oops? Outputs a list in the order faces, corners, edges.

Charcoal, 48 45 bytes
≔Ｅθ↨℅ι²η≔⊘№⭆η⭆ηΣＥι↔⁻§λξν1ηＩＥ⟦⁶⁻⁸η⁻¹²η⟧⁺ι×⊕κＬθ

Try it online! Link is to verbose version of code. Uses digits 0-7 to represent the letters ABDCEFHG in the diagram. Outputs in the order faces, corners, edges. Explanation:
≔Ｅθ↨℅ι²η

Take the ASCII code of each character and convert it to base 2.
≔⊘№⭆η⭆η

Take the cartesian product of the list of base 2 numbers with itself.
ΣＥι↔⁻§λξν1η

XOR the pairs of base 2 numbers together and sum the number of 1 bits. Count how many pairs have a sum of 1 and divide that by 2. This gives the number of coincident corners.
ＩＥ⟦⁶⁻⁸η⁻¹²η⟧⁺ι×⊕κＬθ

Calculate and print the number of faces, corners and edges.

JavaScript (Node.js), 84 bytes
a=>[a.map(u=>a.map(v=>j-=!!'ABCDAEFGHEFBCGHD'.match(u+v),n++,j+=2),n=j=6)|2+j,n+j,n]

Try it online!


text:
Number of circles packed into a rectangle
Calculate the maximum number of circles of radius r that can fit in a rectangle with width x and height y. Write a function that take r, x and y as input and returns the number of circles that fit in the rectangle.

I would suggest to add some testcases so that we can know if any answer is correct.

It appears to me that one could fit at least one more circle, by expanding the second-to-last row to have 10 circles in it, such that the last three rows touch each other orthogonally. Do we not have to handle such cases?

Would it make sense to just normalise and say r is always 1? This way there are only 2 inputs - I believe every answer will  divide through by r.

@ETHproductions I was thinking about fitting more in too, but note that the description states "the circles touch each other in triangular shape".

I want a test case for x=2, r=1. I think the right solution would be circles with a massive gap between, because there has to be place for a potential row between, but the row between is not filled, because x is to small.

Do we have to support floats or are x,y,r guaranteed to be whole numbers?

@BlackOwlKai the description states "the circles touch each other in triangular shape" I believe this means a uniform triangular packing (which matches what is shown in the image).

Is it guaranteed that a side of the rectangle is parallel to a side on the triangular grid?

I suggest putting the challenge in sandbox before posting on main so possible issues can be resolved.

@JonathanAllan Did you mean "so no"?

Without the "triangular lattice" restriction we have https://math.stackexchange.com/questions/701/how-many-circles-of-a-given-radius-can-be-packed-into-a-given-rectangular-box , which is unsolved.

Arbitrary rotation of the grid appears to be very complex (optimal pack of 3 circles in a square, they forms a triangular lattice) and probably not what OP intended. Temporarily VTC as unclear.

@user202729 Ah, true - I suppose they do mean one side must be aligned but had not thought to that point - this certainly needs addressing.

The title of the question "number of circles in a rectangle" takes precedence over "the circles touch each other in triangular shape". A user is not restricted from composing code which interprets the latter as a description of the image at the OP (base case) literally, and discarding that description where the number of circles can be optimized to exceed the base case, else the number of circles at the image at OP cannot be exceeded at all, nullifying the title of the question.

I think it’s a lovely question if there is no restriction on how the circles are packed. It’s also hard so maybe code-golf is not appropriate?

clear, but maybe hard to check currentcy. Suggest max contain then code golf

@guest271314 We don't have a rule that all restrictions must be put in the title (and obviously we should not, otherwise the title will become very long)

@Ourous Why was the edit approved?

@Anush except that we won't know if a solution is correct without a new paper on the topic :)

@JonathanAllen Details, details...:) Maybe an optimization version would work where your have to output the largest packing you can make with a code golf tie break.


text:
Ryley's Theorem
S. Ryley proved following theorem in 1825:

Every rational number can be expressed as a sum of three rational cubes.

Challenge
Given some rational number \$r \in \mathbb Q \$ find three rational numbers \$a,b,c \in \mathbb Q\$ such that $$r= a^3+b^3+c^3.$$
Details
Your submission should be able to compute a solution for every input given enough time and memory, that means having for instance two 32-bit int representing a fraction is not sufficient.
Examples
$$ \begin{align}
30 &= 3982933876681^3  - 636600549515^3 - 3977505554546^3 \\
52 &= 60702901317^3 + 23961292454^3 - 61922712865^3 \\
\frac{307}{1728} &= \left(\frac12\right)^3 + \left(\frac13\right)^3 + \left(\frac14\right)^3 \\
0 &= 0^3 + 0^3 + 0^3 \\
1 &= \left(\frac12\right)^3 + \left(\frac23\right)^3 + \left(\frac56\right)^3\\
42 &= \left(\frac{1810423}{509232}\right)^3 + \left(\frac{-14952}{10609}\right)^3 + \left(\frac{-2545}{4944}\right)^3
\end{align}$$

I had something that kind-of worked in Japt, but it often ran into a "too much recursion" error. Probably because the strategy was "get random numbers, try again until they're a correct answer".

Requiring bignum support unnecessarily excludes a lot of languages, and/or requires a lot of wasted boilerplate to implement them

@Sparr This was a deliberate choice, as the output could be quite "large" even for simple inputs, or depending on what method you use, the intermediate values in the calculation could also be very large. So working with arbitrary precision numbers was an important point for this challenge (and probably quite often in other [tag:number-theory]-challenges too).

Would it be acceptable to output [p1,p2,p3,q], interpreted as $\left(\frac{p_1}{q}\right)^3+\left(\frac{p_2}{q}\right)^3+\left(\frac{p_3}{q}\right)^3$?

Along a similar vein, do the three rational numbers outputted have to be in simplest form?

@Quintec No, they don't have to be reduced.

@Arnauld I think if there is not a fractional type, one should at least use pairs (or lists of length 2) or something along those lines to represent a fraction, but you're making a good point, I did not specify that. (Or do you have another suggestion?)

Using pairs sounds like a reasonable option to me. (This is what I'm currently doing in my answer.)

PARI/GP, 35 bytes
r->[x=r+1/3,-x+r/3/d=x^2-r,1/9/d-1]

Attempt This Online!

PARI/GP, 40 bytes
r->[x=27*r^3+1,9*r-x,z=9*r-27*r^2]/(3-z)

Attempt This Online!

This formula is given in:
Richmond, H. (1930). On Rational Solutions of \$x^3+y^3+z^3=R\$. Proceedings of the Edinburgh Mathematical Society, 2(2), 92-100.
$$r=\left(\frac{27r^3+1}{27r^2-9r+3}\right)^3+\left(\frac{-27r^3+9r-1}{27r^2-9r+3}\right)^3+\left(\frac{-27r^2+9r}{27r^2-9r+3}\right)^3$$
Check it online!

-5 bytes because you can change the order of the summands

@BlackOwlKai The numerator of the second summand is $-27r^{\color{Red}3}+9r-1$, not $-27r^{\color{Red}2}+9r-1$.

Haskell, 95 89 76 69 68 bytes

-18 bytes thanks to H.PWiz
-1 byte thanks to Christian Sievers

f x=[w|n<-[1..],w<-mapM(\_->[-n,1/n-n..n])"IOU",x==sum((^3)<$>w)]!!0

Try it online!
Simple bruteforce solution. It tests all triples of rational numbers of the form
$$
\left(\frac{a_1}{n},\frac{a_2}{n},\frac{a_3}{n}\right)\qquad\text{with }-n\le\frac{a_i}{n}\le n.
$$

We can always assume that the three rational numbers have the same denominator, since
$$
\left(\frac{a_1}{n_1},\frac{a_2}{n_2},\frac{a_3}{n_3}\right)=\left(\frac{a_1n_2n_3}{n_1n_2n_3},\frac{a_2n_1n_3}{n_1n_2n_3},\frac{a_3n_1n_2}{n_1n_2n_3}\right).
$$
We can always assume that \$-n\le\frac{a_i}{n}\le n\$, since
$$
\frac{a_i}{n}=\frac{a_iN}{nN}
$$
for any arbitrarily large integer \$N\$.

What does the "IOU" do?

@SolomonUcko Nothing special, it's as good as any other list of length 3

@H.PWiz I couldn't find any consensus on Meta on whether assuming typed input is accepted, but I still found a way to shorten the code without that assumption. Thanks!

@Delfad0r There is a "consensus" that you do not have to count a possible import, that is only needed to construct the type needed, if you do not explicitly need anything from that import for defining your function. (And you can assume that the correct type is passed to your function, when it is called.)

Save one byte by using [-n,1/n-n..n]

Husk, 14 bytes
ḟo=⁰ṁ^3π3×/NİZ

Simple brute force solution.
Try it online!
Explanation
Division in Husk uses rational numbers by default and Cartesian products work correctly for infinite lists, making this a very straightforward program.
ḟo=⁰ṁ^3π3×/NİZ
            İZ  Integers: [0,1,-1,2,-2,3,-3...
           N    Natural numbers: [1,2,3,4,5...
         ×/     Mix by division: [0,1,0,-1,1/2,0,2,-1/2,1/3...
                This list contains n/m for every integer n and natural m.
       π3       All triples: [[0,0,0],[0,0,1],[1,0,0]...
ḟ               Find the first one
    ṁ^3         whose sum of cubes
 o=⁰            equals the input.

JavaScript (Node.js), 73 bytes
Takes input as (p)(q), where \$p\$ and \$q\$ are BigInt literals.
Returns [[p1,q1],[p2,q2],[p3,q3]] such that \$\frac{p}{q}=\left(\frac{p_1}{q_1}\right)^3+\left(\frac{p_2}{q_2}\right)^3+\left(\frac{p_3}{q_3}\right)^3\$.
p=>q=>[x=p*(y=p*(p*=9n*q*q)*3n/q)/q+(q*=q*q),p-x,p-=y].map(x=>[x,3n*q-p])

Try it online!
Derived from H. W. Richmond (1930), On Rational Solutions of x3 + y3 +z3 = R.

Haskell, 70 bytes
In An introduction to the Theory of Numbers (by Hardy and Wright) there is an construction that even includes a rational parameter. For golfing purposes I just set this parameter to 1, and tried reducing as much as possible. This results in the formula
$$r \mapsto \left[ {{r^3-648\,r^2+77760\,r+373248}\over{72\,\left(r+72\right)^2
 }} , {{12\,\left(r-72\right)\,r}\over{\left(r+72\right)^2}} , -{{r^2
 -720\,r+5184}\over{72\,\left(r+72\right)}} \right] $$
f r|t<-r/72,c<-t+1,v<-24*t/c^3,a<-(v*t-1)*c=((a+v*c+c)/2-)<$>[a,v*c,c]

Try it online!

perl -Mbigrat -nE, 85 bytes
$_=eval;($a,$b)=($_*9,$_**2*27);$c=$b*$_;say for map$_/($b-$a+3),$c+1,-$c+$a-1,-$b+$a

You can save 8 bytes (the leading $_=eval;) if you know the input is an integer; this part is needed to have the program grok an input of the form 308/1728. Input is read from STDIN. I'm using the formula given by @alephalpha.

Maxima, 62 bytes
A port of @alephalpha's Pari/GP code in Maxima.

Try it online!
lambda([r],block([x:27*r^3+1,z:9*r-27*r^2],[x,9*r-x,z]/(3-z)))


text:
Rosencrantz and Guildenstern are Code
In the absurdist play Rosencrantz and Guildenstern are Dead, the two main characters Rosencrantz and Guildenstern(or are they?) are always mixing up which of them is who—or sometimes which of their own body parts is which—because of a perceived lack of individual identity. Wouldn't it be absurd if they even shuffled around their names?
Your task it to write a function which takes in a string of an even length(and by design, a multiple of 4) that is greater than 7 characters, split it, and shuffle it.
The splitting shall be as follows:
the string will be of format "abscd", with s acting as a seperator character. The first section and the separator, abs will be the first half of the string, whereas the second half will be cd
The length of a will be (string length / 4) - 1
The length of b will be (string length / 4)
The length of s will be 1
The length of c will be (string length / 4) + 1
The length of d will be (string length / 4) - 1
This may be really confusing, so let me show you
with some examples
("a" + "bb" + "s" + "ccc" + "d").length //8
  1     2      1      3      1
|-------4--------|  |----4-----| <--- (4 is half of 8)

("rosen" + "crantz" + "&" + "guilden" + "stern").length  //24
    5         6        1        7          5

("foo" + "barr" + "?" + "barry" + "foo").length
   3       4       1      5         3

Finally:
You then shuffle the parts around, outputting adscb
ex. "rosencrantz&guildenstern" --> "rosenstern&guildencrantz"
"foobarr?barryfoo" --> "foofoo?barrybarr"
Rulez:

Standard Loopholes are prohibited
Acceptable answers: a function which takes input through one input string and returns one output string
If the input string doesn't match the requirements provided above,
your code MUST error out(doesn't matter what kind of Exception or
Error)
This is code-golf, so the shortest(valid)answer (in each language)
wins!
Bonus points for a one-liner :-) (Not really tho, just cool points)

Regarding your gangsta rulez: It is generally discouraged to favour "functions", as they are hard to define in general. Furthermore, handling invalid input is also mostly avoided, as it usually boils down to annoying boiler-plate code.

@JonathanFrech I think the challenge of input validation is an interesting problem, as it can be handled a variety of ways from array traversal, to branching logic, to RegEx testing, so optimization of these can add a extra challenge ¯_(ツ)_/¯ I'll try that for another code golf challenge though :-)

tfw everyone is trying to get more flexible io methods to make the code in their favorite golfing lang. and tfw it happens on almost all questions

Things to Avoid when writing challenges (Input Validation).

@JoKing thanks for spotting that!

I'd recommend a test case of length 4 since every answer didn't handle that

@JoKing the spec indicates "greater than 7 characters"

@NathanMerrill And? The first 3 answers didn't handle it correctly, though mine and the K answer have both fixed that since posting.

Perhaps I misunderstand here: "length 4" is not "greater than 7 characters". Why do you think that answers have to handle it?

@NathanMerrill It's mentioned in the spec that input has to be greater than 7 characters in length and its length must be divisible by four, Jo King was suggesting a test case entry of length 4 such "abcd" which should error out

Ah, I understand.  Answers still have to handle it by erroring. :)

Is erroring necessary in languages where catching errors is non-trivial (and thus an error will crash the program), or is it enough to simply produce an output indicating an error, i.e. a null-pointer or empty string?

K (oK), 35 34 33 bytes
{$[8>#x;.;<x!4!-&4#-1 0 2+-4!#x]}

Try it online!
Without input validation (for ngn's bounty), 25 24 23 bytes
{<x!4!-&4#-1 0 2+-4!#x}

Try it online!
Quickly learned a bit of K and, looking at the list of verbs, I thought an alternative approach (not using cut) could work here. And it worked perfectly.
How it works
{<x!4!-&4#-1 0 2+-4!#x}
                 -4!#x    Length divided by four (floor division)
        4#-1 0 2+         Generate lengths (x/4-1, x/4, x/4+2, x/4-1)
       &                  Generate that many 0, 1, 2, 3's
    4!-                   Negate and modulo 4; effectively swap 1 and 3
 <x!                      Sort the original string by above

{$[8>#x;.; <code> ]}  Input validation
 $[8>#x           ]   If the length is less than 8
        .             Dynamically generate an error
           <code>     Otherwise, run the main code

@ngn What happened to my eyes O.o

Python 3, 103 102 101 97 88 86 84 bytes
def f(s):l=len(s);l//=4*(l%4<1<l/4);return s[:l-1]+s[1-l:]+s[2*l-1:1-l]+s[l-1:2*l-1]

Try it online!
Not really a one-liner, but ; is one less byte per line than linebreak and indent.
Throws ZeroDivisionError if input string length is less than 8 or not an integer multiple of 4.
Also works in Python 2.
-4 bytes thanks to Jo King
-9 bytes thanks to ovs
-2 bytes thanks to Jonathan Frech
-2 bytes thanks to Bubbler

@JoKing thanks for the tips, much appreciated :)

88 bytes

@ovs nice catch on the adjacent indexes, as for the parens, I tried around for at least 20 minutes to see if I could get rid of some of them, then I completely missed that with the change to //= the outermost pair became redundant. Thanks a bunch!

-l+1 <-> 1-l?

Merge the two inequalities to get to 84 bytes.

Perl 6, 60 58 bytes
-2 bytes thanks to Jo King
{[~] .rotor($_/4 X-1,0,+^-$_+>2,-1,1)[0,4,2,3,1;*]}o*.comb

Try it online!
Throws "Rotorizing sublist length is out of range" in case of error.
Explanation
{               # Anonymous block
 [~]            # Join
   .rotor(      # Split into sublists of specific length
     $_/4 X-    # Subtract from len/4
     1,
     0,
     +^-$_+>2,  # (len-1)>>2
                #   subtraction yields 1 if len is multiple of 4
                #   otherwise a value less than 1 causing an error
     -1,
     1)
   [0,4,2,3,1;*]  # Rearrange sublists and take inner elements
}o*.comb          # Split into characters and feed into block

J, 36 35 bytes
5;@A.](<;.2~;)1<@{."+~1 0 _2 1-4%~#

Try it online!
-1 byte by {. + negative lengths & ;.2 which cuts on ones as "ending" markers instead.
Original answer, 36 bytes
5;@A.](<;.1~;)1<@{."+~_1 0 2 _1+4%~#

Try it online!
ngn mentioned "cut" on a comment to an earlier K answer, and it made me try J which has the same "cut" (I have no idea how K works).
How it works
5;@A.](<;.1~;)1<@{."+~_1 0 2 _1+4%~#  Monadic train.
                                4%~#  Length divided by four
                      _1 0 2 _1+      Generate the four segment lengths
              1<@{."+~  Generate [1 0 0...] boxed arrays of those lengths
      (     ;)          Raze; unbox and concatenate
     ] <;.1~            Cut the input string on ones as starting marker, then box each
5  A.  Rearrange the boxes in the order 0 3 2 1
 ;@    Raze again

Note that this function automatically handles invalid inputs:

If the input length is not a multiple of four, {. throws domain error since its length argument has to be integers.
If the input length is 4, the cut produces only two segments, and 5 A. throws index error.
If the input length is 0, the two arguments to cut don't have the same length, so length error is thrown.

K (ngn/k), 120 113 103 99 95 bytes
{$[(r>7)&0=4!r:#:x;{g:(s:*|(y*2)#x)\x;((y-1)#*g),((-y-1)#*|g),s,((y+1)#*|g),(-y)#*g}[x;r%4];l]}

Hopefully can be golfed down more, included an extra function for testing if string length is divisible by four, outputs error with reference to undeclared variable if input is invalid
EDIT: Missed condition on length greater than 7, included
EDIT: Combined into one function, removed redundant variable declarations
Try it online!

this could be a lot shorter. do you know about "cut" (indices_string)? ping me in the orchard if i should explain it

i can do it in 34 bytes :)

I know about cut, but I didn't think about using it... 34 bytes?!
I'm going to have to give this another go when I get home and see if I get near that

i should mention: my solution doesn't make sure that invalid inputs (length<=7) cause an error

Perl 6, 78 bytes
*.comb[0..*/4-2,3* */4+1..*,*/2-1/(*>7)..3* */4,*/4-1/(*%%4)..*/2-2].flat.join

Try it online!
Anonymous code block that takes a string and returns the modified string if valid, else returns a division by zero error. I know I can modify an array directly, so I could swap the two sections of the string, but I can't quite figure it out.

Ruby, 64 bytes
->s{a=s.size/4;s[1-a,a],s[a-1,a]=s[a-1,a],s[1-a,a];s[a*4]?1/0:s}

Try it online!

C (gcc) with -Dx=memcpy and -DL=(l-1), 154 158 160 bytes
Returns NULL if the input string length is not divisible by 4 or shorter than 8 characters.
Thanks to Rogem and Jonathan Frech for the suggestions.
EDIT: Moved preprocessor defines to the command line and made the string dynamically-allocated to strictly conform with the puzzle.
f(s,t,l)char*s,*t;{l=strlen(s);l%4|l<8?t=0:(t=malloc(l+1),l/=4,x(t,s,L),x(t+L,s+3*l+1,L),x(t+2*L,s+L+l,l+2),x(t+3*l,s+L,l),t[4*l]=0);l=t;}//-Dx=memcpy -DL=(l-1)

Try it online!

Why t[80]? There does not seem to be an upper bound regarding input length.

@JonathanFrech I did it to save bytes but you are correct. I've changed the solution to use malloc() instead.

Returns by modification, return value is NULL for invalid output, uses return values from memcpy(), a function-like macro to skip the types and C99 variable-length arrays to skip malloc().

Why 160 bytes, do you count the // or the -w?

@l4m2 -w is just a convenience to suppress warnings (so errors are easier to find). I usually add command line arguments after a // to have TIO count their bytes for me, and then deduct 1 from the total to account for the one extra character needed to do that.

@ceilingcat I've posted as a competing solution.

Retina 0.8.2, 58 or 73 or 83 or 93 bytes
((((.)))*?)(.(?<-2>.)+)(...(?<-3>.)+)((?<-4>.)+)$
$1$7$6$5

Try it online! Explanation:
((((.)))*?)

Capture a in $1, and make it as short as possible *?. $#2, $#3 and $#4 end up as the length of a.
(.(?<-2>.)+)

Capture b in $4. The (?<-2>.)+ captures up to the length of a, while the other . adds 1 to its length as required.
(...(?<-3>.)+)

Capture s and c in $6. Their combined length is three more than the length of a.
((?<-4>.)+)

Capture d in $7. Its length is no more than the length of a.
$

We made a as short as possible, but we still want to reach the end of the input.
$1$7$6$5

Exchange b and d.
The above stage does not validate its input. As Retina has no run-time errors, there are a number of options for input validation:
G`^(....){2,}$

Outputs nothing if the length is less than 8 or not a multiple of 4. (+15 bytes)
^(?!(....){2,}$).*
Error

Outputs Error if the length is less than 8 or not a multiple of 4. (+25 bytes)
+`^(....)*..?.?$|^(....)?$
.....$1

Hangs if the length is less than 8 or not a multiple of 4. (+35 bytes)

This doesn't throw an error on invalid inputs (as annoying as that is)

JavaScript (ES6), 97 89 bytes
Saved 8 bytes thanks to @l4m2
s=>(l=s.length/4)<2||l%1?Z:s.replace(eval(`/(.{${l}})(.{${l+2}})(.{${l-1}})$/`),'$3$2$1')

Try it online!

89B

Jelly, 28 bytes
L7»4ḍİ×L:4;;ĖÄƲFÄœṖ⁸⁽%[D¤ị$F

(If a full program is allowed we can remove the trailing F)
If the length is less than 8 or not divisible by four a ValueError is raised during integer division of inf (a float) by 4 -- the division yields NaN (also a float) which then cannot be cast to an int.
Try it online!
How?
L7»4ḍİ×L:4;;ĖÄƲFÄœṖ⁸⁽%[D¤ị$F - Link: list of characters
L                            - length
 7                           - literal seven
  »                          - maximum (of length & 7)
   4ḍ                        - divisible by four? (yields 1 for good inputs; 0 otherwise)
     İ                       - inverse (1 yields 1; 0 yields inf)
      ×L                     - multiply by length (length or inf)
        :4                   - integer divide by 4 (errors given inf)
              Ʋ              - last four links as a monad (f(x)):
          ;                  -   concatenate -> [x,x]
            Ė                -   enumerate -> [1,x]
           ;                 -   concatenate -> [x,x,[1,x]]
             Ä               -   cumulative sum (vectorises at depth 1) -> [x,x,[1,1+x]]
               F             - flatten -> [x,x,1,1+x]
                Ä            - cumulative sum -> [x,2x,2x+1,3x+2]
                   ⁸         - chain's left argument (the input)
                 œṖ          - partition at indices (chops up as per requirements)
                          $  - last two links as a monad (f(z)):
                        ¤    -   nilad followed by link(s) as a nilad:
                    ⁽%[      -     10342
                       D     -     decimal digits -> [1,0,3,4,2]
                         ị   -   index into z (rearranges the pieces as per requirements)
                           F - flatten (back to a list of characters)

JavaScript (Node.js), 80 bytes
s=>(g=s.substr.bind(s))(0,l=s.length/4-1)+g(-l)+g(l-~l,l+3)+g(l,l+1,l<1==l%1||Z)

Try it online!
JavaScript (Node.js), 84 bytes
s=>(g=(a,b)=>s.substr(a,b))(0,l=s.length/4-1)+g(-l)+g(l-~l,l+3)+g(l,l+1,l<1==l%1||Z)

Try it online!
JavaScript (Node.js), 87 bytes
s=>(l=s.length/4)<2||l%1?Z:(g=(a,b)=>s.substr(a,b))(0,l-1)+g(1-l)+g(l+l-1,l+2)+g(l-1,l)

Try it online!
Shorter than RegExp

Jelly, 25 bytes
L:4’+“¡¢¢£¡‘Ṡ3¦ÄṬk⁸Ṛ2,5¦Ẏ

Try it online!
The Ẏ can be removed to make this into a full program.

Java 8, 135 bytes
s->{int l=s.length();l=l>7&l%4<1?l/4:l/0;return s.substring(0,l-1)+s.substring(3*l+1)+s.substring(2*l-1,3*l+1)+s.substring(l-1,2*l-1);}

Throws ArithmeticException (divides by zero) if the input string does not match requirements. Try it online here.
Ungolfed:
s -> { // lambda function taking a String argument and returning a String
    int l = s.length(); // take the length of the input ...
    l = l > 7 &         // ... if it's  greater than 7 and ...
        l % 4 < 1       // ... a multiple of 4 ...
      ? l / 4           // ... divide by 4; otherwise ...
      : l / 0;          // ... error out (division by zero throws ArithmeticException)
    return // concatenate and return:
           s.substring(0, l - 1)             // a
         + s.substring(3 * l + 1)            // d
         + s.substring(2 * l - 1, 3 * l + 1) // sc
         + s.substring(l - 1, 2 * l - 1);    // b
}

Suggest l/=l>7&l%4<1?4:0; instead of l=l>7&l%4<1?l/4:l/0;

C (gcc), 129 bytes
Returns by modification.
Compile with:
-Df(s)=({char t[l=strlen(s)];l%4|l<8?0:(l/=4,x(t,s+l*2-1,l-~l),x(x(x(s+l*3,s+l-1,l)-l-2,t,l+2)-l+1,t+l+2,l-1),s);}) -Dx=memcpy

Source file:

l;

Try it online!
Degolf
-Df(s)=({ // Function-like macro f. Takes a char* as a parameter.
          // Return value is a pointer to s if successful, and to NULL if string was invalid.
     char t[l=strlen(s)]; // Allocate a local temp string.
     l%4|l<8?0: // Detect invalid strings. Return 0 (NULL) on invalid string.
         (l/=4, // We're only really concerned with floor(len/4), and this will yield that.
             memcpy(t,s+l*2-1,l-~l), // Copy the second half of chars to the temp storage.
             memcpy( // Because memcpy returns the address of the destination, we can chain
                     // the calls to save quite a few bytes, even after x->memcpy substitution.
                 memcpy(memcpy(s+l*3,s+l-1,l) // Next, copy the second quarter to the end.
                     -l-2,t,l+2) // After that, we copy back the third quarter to its place.
                          -l+1,t+l+2,l-1) // Finally, copy the fourth quarter to where the second
                                          // quarter was.
                      ,s);}) // And return the pointer.