text:
Go generate some Java
Your boss wants you to write code like this:
public static boolean isPowerOfTen(long input) {
  return
    input == 1L
  || input == 10L
  || input == 100L
  || input == 1000L
  || input == 10000L
  || input == 100000L
  || input == 1000000L
  || input == 10000000L
  || input == 100000000L
  || input == 1000000000L
  || input == 10000000000L
  || input == 100000000000L
  || input == 1000000000000L
  || input == 10000000000000L
  || input == 100000000000000L
  || input == 1000000000000000L
  || input == 10000000000000000L
  || input == 100000000000000000L
  || input == 1000000000000000000L;
}

(Martin Smith, at https://codereview.stackexchange.com/a/117294/61929)
which is efficient and so, but not that fun to type. Since you want to minimize the number of keypresses you have to do, you write a shorter program or function (or method) that outputs this function for you (or returns a string to output). And since you have your very own custom full-range unicode keyboard with all 120,737 keys required for all of unicode 8.0, we count unicode characters, instead of keypresses. Or bytes, if your language doesn't use unicode source code.
Any input your program or function takes counts towards your score, since you obviously have to type that in as well.
Clarifications and edits:

Removed 3 trailing spaces after the last }
Removed a single trailing space after return
Returning a string of output from a function/method is ok

0==Math.log10(input)%1

You say "we count unicode characters," but then you immediately say "Or bytes." Which one is it?

Whichever you prefer, i.e. the one that gives you the lowest score. Added bytes to allow languages that don't use text source.

while(input%10==0) input/=10; return input == 1;

@FilipHaglund Your comment seems to make the scoring a little unfair. I could write a program in bytecode, and say its unicode to shave off a few bytes... Maybe you meant what you stated in the question; that you should only count in unicode if your program is written in it?

I don't want to exclude languages that don't use unicode, or languages that do use unicode. Do you have a suggested edit to the rules? It doesn't seem like anyone has used unicode yet in an answer.

@FilipHaglund The 05AB1E answer uses unicode.  Unless I am wildly mistaken and "Æ£‹ÒŒ€" isn't unicode (answer was posted 4 hours prior to your comment).  As to your rules, they are pretty much the standard for golf ("shortest program + input"), but presented more humorously ("pressing buttons is hard!").

05AB1E uses windows CP1252, which is bytes, not unicode. I'm aiming for standard rules, but I get told I'm wrong all the time.

No bonus points for having Go generate some Java? :P

You can have -10 bytes if you use go:generate ;)

Most of us spent extra characters to reproduce the code and formatting. Then you post your own answer where you just use some \t for indentation. You could specify that from the beginning.

Woops, my bad, @manatwork . Will change that when I get back home. It should be spaces! Thanks for pointing that out.

@Dennis trailing spaces are removed, and should never have been there in the first place.

@manatwork My answer should now be correct. Please check for yourself :)

Thanks @FilipHaglund, now the expectations are more clearly set.

OK, thanks. I've edited my answer.

PostgreSQL, 158 characters
select'public static boolean isPowerOfTen(long input) {
  return
   '||string_agg(' input == 1'||repeat('0',x)||'L','
  ||')||';
}'from generate_series(0,18)x

I have never seen an RDBMS used as a code golf answer... sweet! +1

@ChrisCirefice SQL is actually somewhat common on this site. (Or at least more common than one might expect.)

@AlexA. Hm, well PCG is one of my less-frequented SE sites, so I've never seen a SQL answer :)

CJam, 52 characters
YA#_(""f&bY7#b:c~

Try it online!
Stage 1
Using Unicode characters U+10000 to U+10FFFF, we can encode 20 bits in a single character. CJam uses 16-bit characters internally, so each one will be encoded as a pair of surrogates, one in the range from U+D800 to U+DBFF, followed by one in the range from U+DC00 to U+DFFF.
By taking the bitwise AND of each surrogate with 1023, we obtain the 10 bits of information it encodes. We can convert the resulting array from base 1024 to base 128 to decode an arbitrary string of Unicode characters outside the BMP to an ASCII string.
The code does the following:
YA#    e# Push 1024 as 2 ** 10.
_(     e# Copy and decrement to push 1023.

""

f&     e# Apply bitwise AND with 1023 to each surrogate character.
b      e# Convert the string from base 1024 to integer.
Y7#    e# Push 128 as 2 ** 7.
b      e# Convert the integer to base 128.
:c     e# Cast each base-128 to an ASCII character.
~      e# Evaluate the resulting string.

Stage 2
The decoding process from above yields the following source code (98 bytes).
"public static boolean isPowerOfTen(long input) {
  return
   ""L
  || input == ":S6>AJ,f#S*"L;
}"

Try it online!
The code does the following:
e# Push the following string.

"public static boolean isPowerOfTen(long input) {
  return
   "

e# Push the following string and save it in S.

"L
  || input == ":S

e# Discard the first 6 characters of S. The new string begins with " input".

6>

e# Elevate 10 (A) to each exponent below 19 (J).

AJ,f#

e# Join the resulting array, using the string L as separator.

S*

e# Push the following string.

"L;
}"

You might expect a SE site like Judaism to be the ones stress-testing the site's unicode support, but this is crazy :D

I can see exactly two of the characters between the quote marks. Can you post a hexdump?

You can actually see two of them? I have no such luck... Encoding the characters as UTF-8, the hexdump would look like this. https://tio.run/nexus/bash#AagAV///eHhkIC1nIDH//1lBI18oIvCQgJHygLq484aanPG4jp/xnI@T8Z6NgfKbn6/zqaWw876QmvKJtI30jbyv8Lm@mvK2l5zys5mv862nkPG5t5zxir2F8LiPmPK0goPyppep86elrvCkoJDwsJGI8raCpPCYj6fzlIan8oeDq/OhgL3yiqCR8YqprfKvkJnxm4yy8YqaqfCksbbwu7qiImYmYlk3I2I6Y34

Java, 217 215 220 219 192 bytes
Golfed:
public static String b(){String s="public static boolean isPowerOfTen(long input) {\n  return\n    input == 1L",z="";for(int i=0;i++<18;){z+="0";s+="\n  || input == 1"+z+"L";}return s+";\n}";}

Ungolfed:
  public static String a(){
    String s = "public static boolean isPowerOfTen(long input) {\n  return\n    input == 1L", z="";
    for (int i=0; i++ < 18;) {
        z += "0";
        s += "\n  || input == 1"+z+"L";
    }
    return s + ";\n}";
  }

(first answer, wuhu)
Thanks!
-2 bytes: user902383
-1 byte: Denham Coote
Changes:

used tabs instead of spaces
missed the last line of output: 18 -> 19
removed inner loop
changed from printing to returning string

your inner for loop does not need brackets

Use Java 8 syntax, also shortened some other stuff: ()->{String s="public static boolean isPowerOfTen(long input) {\n\treturn input == 1L";for(int i=0,k;i++<18;){s+="\n\t|| input == 1";for(k=0;k++<i;)s+="0";s+="L";}return s+";\n}";} (180 bytes) Now returns the string instead of printing, but that's shorter.

+1 for writing a verbose Java program to generate an even more verbose Java program.

instead of for(int i=1;i<19;i++) you can write for(int i=1;i++<19;) which saves a byte

Also, declare  int i=1,k; and then you can write for(;i++<19;) and for(k=0;k++<i;)

05AB1E, 99 97 96 94 93 87 bytes
Code:
“‚Æ£‹ÒŒ€ˆPowerOfTen(“?“¢„î®) {
 «‡
   “?19FN0›i"  ||"?}’ î® == ’?N°?'L?N18Qi';,"}"?}"",

Try it online!
Uses CP-1252 encoding.

Vim 97 keystrokes
ipublic static boolean isPowerOfTen(long input) {
  return
  || input == 1L<esc>qyYpfLi0<esc>q16@yo}<esc>3Gxx

Well, I'm on a roll today with vim producing java, so why not continue the trend!

replacing fL with $ could save you a keystroke

Also, the third line input == 1L is misaligned by one byte...

So the last x should be changed to r<sp> and then the number of keystrokes would be unchanged

PowerShell, 120 bytes
'public static boolean isPowerOfTen(long input) {'
'  return'
"   $((0..18|%{" input == 1"+"0"*$_})-join"L`n  ||")L;`n}"

The first two lines are simply string literals, which are output as-is.
The third line starts with three spaces, and ends with L;`n}" to finish off the last couple bytes. The middle bit inside the script block $(...) is constructed by for-looping % from 0 to 18 and each iteration constructing a string that starts with  input == 1 concatenated with the corresponding number of zeros. This will spit out an array of strings. We then -join each element of the array with L`n  || to achieve the newline-pipes. That big string is the output of the script block, which gets inserted automatically into the middle and output.
PS C:\Tools\Scripts\golfing> .\go-generate-some-java.ps1
public static boolean isPowerOfTen(long input) {
  return
    input == 1L
  || input == 10L
  || input == 100L
  || input == 1000L
  || input == 10000L
  || input == 100000L
  || input == 1000000L
  || input == 10000000L
  || input == 100000000L
  || input == 1000000000L
  || input == 10000000000L
  || input == 100000000000L
  || input == 1000000000000L
  || input == 10000000000000L
  || input == 100000000000000L
  || input == 1000000000000000L
  || input == 10000000000000000L
  || input == 100000000000000000L
  || input == 1000000000000000000L;
}

A long time ago... :) Very impressive!

Pyth, 118 106 103 bytes
s[."
{Z-L¡JxÙÿ
LæÝ<í?¢µb'¥ÜA«Ç}h¹äÚÏß"\nb*4dj"\n  || "ms[." uøs|ÀiÝ"*d\0\L)U19\;b\}

Try it online!
All this string hardcoding really eats a lot of bytes up, but nothing I can do about it.
Update: Saved 3 bytes by using a packed string. Thanks @user81655 for the hint!

You could use packed strings...

I don't know Pyth and I'm not sure if there's a way to pack the full string (the packing program would always alter it) but packing up to r and concatenating the n results in this (98 bytes).

@user81655 Thanks, didn't know Pyth had this. :) It only makes sense to pack the first big string tho, the overhead you produce form unpacking is not worth it for smaller string.

@user81655 I am aware of that, but I count 103 characters. How did you get to 97?

Oops, my mistake, I was counting them wrong.

C# (CSI) 181 180 179 byte
string i=" input == 1",e="public static bool";Console.Write(e+@"ean isPowerOfTen(long input) {
  return
   "+i+string.Join(@"L
  ||"+i,e.Select((_,x)=>new string('0',x)))+@"L;
}")

There is only one little trick involved. The straight forward way to write this would be:
string.Join("L\n  || input == 1",Enumerable.Range(0,18).Select(x=>new string('0',x)))

by using the string with the first 18 characters of the text which I need anyways I can get rid off the lengthy Enumerable.Range. This works because string implements IEnumerable and there is a  version of Select that hands the item (not needed) and the index which we want to the lambda function.

@WashingtonGuedes Thanks

add some explanation please

Does CSI support expression bodies? If so, the { return ... } can be replaced by =>....

Not currently on computer so I can't test this. Does the last verbatim string escape the bracket inside it? Or is it a great trick that I didn't know of? :)

Javascript, 172 157 152 150 148 bytes
p=>`public static boolean isPowerOfTen(long input) {
  return${[...Array(19)].map((x,i)=>`
  ${i?'||':' '} input == 1${'0'.repeat(i)}L`).join``};
}`

f=p=>`public static boolean isPowerOfTen(long input) {
  return${[...Array(19)].map((x,i)=>`
  ${i?'||':' '} input == 1${'0'.repeat(i)}L`).join``};
}`

document.body.innerHTML = '
' + f() + '
'

In ES7 you can save 9 bytes by using ${10**i} instead of 1${'0'.repeat(i)}.

C, 158 155 bytes
i;main(){for(puts("public static boolean isPowerOfTen(long input) {\n  return");i<19;)printf("  %s input == 1%0.*dL%s\n",i++?"||":" ",i,0,i<18?"":";\n}");}

Try it online here.

You can shave off a byte if you use the return value of printf:
i;main(){for(puts("public static boolean isPowerOfTen(long input) {\n  return");printf("  %s input == 1%0.*dL%s\n",i++?"||":" ",i,0,i<18?"":";\n}")-37);}

Jelly, 75 bytes
(These are bytes in Jelly's custom codepage.)
0r18⁵*;@€⁶j“¢œḤḅg^NrÞḢ⁷ẉ»“⁵®UẆƓḃÐL⁴ṖịṛFþẈ¹9}¶ ƁḋȮ¦sẒẆd€Ḟɼ¿ỌṀP^µ\f@»;;“L;¶}”

Try it here.
Explanation
0r18      Range [0..18]
⁵*        Take the 10^ of each number
;@€⁶      Prepend a space to each number
j“...»    Join by compressed string "L\n  || input =="
“...»;    Prepend compressed string "public static ... =="
;“L;¶}”   Append "L;\n}"

ES6, 139 138 bytes

document.write(`
${(

_=>"0".repeat(19).replace(/./g,`
 || input == 1$\`L`).replace(`
 ||`,`public static boolean isPowerOfTen(long input) {
  return
  `)+`;
}`

)()}
`);

I do so love these triangle generation questions. Note: Snippet includes header and footer, but these aren't included in the byte count.

Vimscript, 120 bytes
Might as well use the right tool for the job.
This assumes that autoindent, etc have not been set.  ^[ and ^M are escape characters for the ESC and CR characters respectively.
The a macro duplicates the current line and adds a 0 to the copy.
The :norm line generates all the boilerplate and the indent == 1L line, then uses a to create the others.
:let @a='yyp$i0^['
:norm ipublic static boolean isPowerOfTen(long input) {^M  return^M  || input == 1L^[18@a$a;^M}
:3s/||/ /

In case the trailing spaces the sample output had on two lines weren't typos, here's a 126 byte version that includes them.
:let @a='yyp/L^Mi0^['
:norm ipublic static boolean isPowerOfTen(long input) {^M  return ^M  || input == 1L^[18@a$a;^M}
:3s/||/ /

Ruby, 125 119 bytes
$><<'public static boolean isPowerOfTen(long input) {
  return
   '+(0..19).map{|i|" input == #{10**i}L"}*'
  ||'+';
}'

Thanks to manatwork for -6 bytes!

Not much original as most of the solutions are doing this way, but still shorter: http://pastebin.com/1ZGF0QTs

jq, 123 characters
(121 characters code + 2 characters command line option.)
"public static boolean isPowerOfTen(long input) {
  return
   \([range(19)|" input == 1\("0"*.//"")L"]|join("
  ||"));
}"

Sample run:
bash-4.3$ jq -nr '"public static boolean isPowerOfTen(long input) {
>   return
>    \([range(19)|" input == 1\("0"*.//"")L"]|join("
>   ||"));
> }"'
public static boolean isPowerOfTen(long input) {
  return
    input == 1L
  || input == 10L
  || input == 100L
  || input == 1000L
  || input == 10000L
  || input == 100000L
  || input == 1000000L
  || input == 10000000L
  || input == 100000000L
  || input == 1000000000L
  || input == 10000000000L
  || input == 100000000000L
  || input == 1000000000000L
  || input == 10000000000000L
  || input == 100000000000000L
  || input == 1000000000000000L
  || input == 10000000000000000L
  || input == 100000000000000000L
  || input == 1000000000000000000L;
}

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)

Oracle SQL 9.2, 311 bytes
SELECT REPLACE(REPLACE('public static boolean isPowerOfTen(long input) {'||CHR(10)||'  return'||c||';'||'}', 'n  ||', 'n'||CHR(10)||'   '),CHR(10)||';', ';'||CHR(10)) FROM(SELECT LEVEL l,SYS_CONNECT_BY_PATH('input == '||TO_CHAR(POWER(10,LEVEL-1))||'L'||CHR(10),'  || ')c FROM DUAL CONNECT BY LEVEL<20)WHERE l=19

Perl 5 - 130 141
@s=map{'input == 1'.0 x$_."L\n  ||"}0..18;$s[$#s]=~s/\n  \|\|/;\n}/g;print"public static boolean isPowerOfTen(long input){\n  return\n    @s"

EDIT: fixed to have exact indentation

No need to use parenthesis around the range. In change would be nice to reproduce the exact indentation.

Thanks for the parenthesis that I forgot. I've fixed it to have the exact indentation.

There is no need for the g flag for the substitution. Also as you have a single \n in that string, you can simply match it and everything after it: $s[$#s]=~s/\n.+/;\n}/. But a join based one would still be shorter: http://pastebin.com/hQ61Adt8

Thank you, but I don't think it would be nice if I just copied and pasted your solution, so I'll just leave it as it is as my own best effort. In time, I'll get better at golfing :-)

Kotlin, 194 193 characters
fun main(u:Array<String>){var o="public static boolean isPowerOfTen(long input) {\n\treturn"
var p:Long=1
for(k in 0..18){
o+="\n\t"
if(k>0)o+="||"
o+=" input == ${p}L"
p*=10
}
print("$o;\n}")}

Test it at http://try.kotlinlang.org/

Welcome to Programming Puzzles & Code Golf. Nice first answer, but please add a link to an online interpreter or add an example on how to run this program, so others can verify it. However, have a great time here! :)

Python (3.5) 137 136 bytes
print("public static boolean isPowerOfTen(long input) {\n  return\n   ",'\n  || '.join("input == %rL"%10**i for i in range(19))+";\n}")

Previous version
print("public static boolean isPowerOfTen(long input) {\n  return\n   ",'\n  || '.join("input == 1"+"0"*i+"L"for i in range(19))+";\n}")

135 with Python 2.7: print "public static boolean isPowerOfTen(long input) {\n  return\n    %s;\n}"%"\n  || ".join("input == %r"%10L**i for i in range(19))

@moooeeeep you're right, the use of %r win 1 bytes and the python 2 print (without parenthesis ) win another one

Javascript 175 bytes
Let's do this regularly
var s = "public static boolean isPowerOfTen(long input) {\n\treturn\n\t\tinput == 1";
for (var i = 1; i < 20; i++) {
    s += "\n\t|| input == 1";
    for (var j = 0; j < i; j++) {
        s += "0";
    }
    s += "L" ;
}
s += ";\n}";
alert(s);

Pretty small. Now, some javascript magic, like no semicolons needed, or no var's, etc.:
k="input == 1"
s="public static boolean isPowerOfTen(long input) {\n\treturn\n\t\t"+k+"L"
for(i=1;i<20;i++){s+="\n\t|| "+k
for(j=0;j<i;j++)s+="0";s+="L"}s+=";\n}"
alert(s)

Can you explain how that magic works? :)

Javascript doesn't care about semicolons, at least until the keywords (for, while, var, etc.) aren't "touching" anything else. Also, if you don't use the var keyword, you get global variables, wich is the worst feature I have ever seen in a programming language thus far.

@Bálint. Why this would be the worst feature?

@WashingtonGuedes You know, most languages remind you if you misstyped something inside a function. Because javascript takes that as if you made a whole new variable, it does not going to say anything about that.

Also, same one applies to = returning a true.

T-SQL 289, 277, 250, 249 bytes
SELECT'public static boolean isPowerOfTen(long input){return '+STUFF((SELECT'||input=='+N+'L 'FROM(SELECT TOP 19 FORMAT(POWER(10.0,ROW_NUMBER()OVER(ORDER BY id)),'F0')N FROM syscolumns)A FOR XML PATH(''),TYPE).value('.','VARCHAR(MAX)'),1,2,'')+';}'

Update: Thanks @Bridge, I found a few more spaces too :)
Update2: Changed CTE to subquery -27 chars :)
Update3: Another space bites the dust @bridge :)

I was able to trim off 7 more spaces (282 bytes) without changing the rest of the code: WITH A AS(SELECT CAST('1'AS VARCHAR(20))N UNION ALL SELECT CAST(CONCAT(N,'0')AS VARCHAR(20))FROM A WHERE LEN(N)<20)SELECT'public static boolean isPowerOfTen(long input){return '+STUFF((SELECT'|| input=='+N+'L 'FROM A FOR XML PATH(''),TYPE).value('.', 'VARCHAR(MAX)'), 1, 3, '')+';}'

Now I look back I can see all the extra spaces in my original comment! I've found one more space you can get rid of - the one immediately after ROW_NUMBER()

Java,  210 / 166
Score is depending on whether returning the input from a function meets the definition of 'output'.
Console output (210):
class A{public static void main(String[]z){String a=" input == 1",t="L\n  ||"+a,s="public static boolean isPowerOfTen(long input) {\n  return\n   "+a;for(int i=0;++i<19;)s+=t+="0";System.out.print(s+"L;\n}");}}

String return (166):
String a(){String a=" input == 1",t="L\n  ||"+a,s="public static boolean isPowerOfTen(long input) {\n  return\n   "+a;for(int i=0;++i<19;)s+=t+="0";return s+"L;\n}";}

Legible version:
String a() {
    String a=" input == 1", t = "L\n  ||"+a,
        s = "public static boolean isPowerOfTen(long input) {\n  return\n   "+a;
    for (int i = 0; ++i < 19;)
        s += t += "0";
    return s + "L;\n}";
}

ANSI-SQL, 252 characters
WITH t as(SELECT '   'x,1 c,1 l UNION SELECT'  ||',c*10,l+1 FROM t WHERE l<19)SELECT 'public static boolean isPowerOfTen(long input) {'UNION ALL SELECT'  return 'UNION ALL SELECT x||' input == '||c||'L'||SUBSTR(';',1,l/19)FROM t UNION ALL SELECT'}   ';

Ungolfed:
WITH t as (SELECT '   ' x,1 c,1 l UNION
           SELECT '  ||',c*10,l+1 FROM t WHERE l<19)
SELECT 'public static boolean isPowerOfTen(long input) {' UNION ALL
SELECT '  return ' UNION ALL
SELECT x||' input == '||c||'L'||SUBSTR(';',1,l/19) FROM t UNION ALL
SELECT '}   ';

Not a serious attempt, just poking at the Oracle SQL/T-SQL entries.

For 40 additional chars I can add "from dual " and make it an "Oracle SQL" entry.

JavaScript (Node.js), 156 bytes
s="public static boolean isPowerOfTen(long input) {\n  return "
for(i=1;i<1e19;i*=10)s+="\n  "+(i-1?"||":" ")+" input == "+i+"L"
console.log(s+";\n}   \n")

The i-1 will only be 0 (and thus falsey) on the very first round (it's just slightly shorter than i!=1.
Suggestions welcome!

Perl 5, 137 bytes
Not based on the previous Perl answer, but it is somehow shorter. I believe it can be shortened down again by taking care of the first "input" inside the loop, but I didn't try anything yet (at work atm)
$i="input";for(1..18){$b.="  || $i == 1"."0"x$_."L;\n"}print"public static boolean isPowerOfTen(long $i) {\n  return\n    $i == 1L;\n$b}"

CJam, 112 chars
"public static boolean isPowerOfTen(long input) {
  return
    input == 1"19,"0"a19*.*"L
  || input == 1"*"L;
}"

Batch, 230 208 206 205 bytes
@echo off
echo public static boolean isPowerOfTen(long input) {
echo   return
set m=input == 1
echo    %m%L
for /l %%a in (1,1,17)do call:a
call:a ;
echo }
exit/b
:a
set m=%m%0
echo  ^|^| %m%L%1

Edit: Saved 22 bytes by avoiding repeating input == and reusing the subroutine for the line with the extra semicolon. Saved 2 3 bytes by removing unnecessary spaces.

Do you need spaces around ==?

@Pavel That's not code; it's part of the output.

AWK+shell, 157 bytes
echo 18|awk '{s="input == 1";printf"public static boolean isPowerOfTen(long input) {\n return\n    "s"L";for(;I<$1;I++)printf"\n  ||%sL",s=s"0";print";\n}"}'

The question did say to count everything you would have to type.
This does have the added bonus of being able to select how many lines would be placed in the isPowersOfTen method when the boss inevitably changes his mind.

Passing a here-string is shorter than piping from echo: awk '…'<<<18

I knew about here-file but not here-string. Thanks for the info.

Perl 6 (115 bytes)
say "public static boolean isPowerOfTen(long input) \{
  return
   {join "L
  ||",(" input == "X~(10 X**^19))}L;
}"

X operator does list cartesian product operation, for example 10 X** ^19 gives powers of ten (from 10 to the power of 0 to 19, as ^ is a range operator that counts from 0). Strings can have code blocks with { (which is why I escape the first instance of it).

R, 185 bytes
Golfed
options(scipen=999);p=paste;cat(p("public static boolean isPowerOfTen(long input) {"," return",p(sapply(0:19,function(x)p(" input == ",10^x,"L",sep="")),collapse="\n ||"),"}",sep="\n"))

Ungolfed
options(scipen=999)
p=paste
cat(
  p("public static boolean isPowerOfTen(long input) {",
        " return",
        p(sapply(0:19,function(x)p(" input == ",10^x,"L",sep="")),collapse="\n ||"),
        "}",
        sep="\n")
)

Zsh, 125 bytes
P="public static boolean isPowerOfTen(long input) {
  return
   ${1= input == 1}L"
repeat 18 {1+=0;P+="
  ||$1L";}
<<<$P";
}"

Try it online!

05AB1E, 71 bytes
18Ý°'L«“  ||î® == “ì”„‡€‚—¿”á
“‚Æ£‹ÒŒ€ˆÿ(ƒÈî®) {
 „Á“š»…;
}«„( ¬:„||ð.;

Try it online.
Explanation:
18Ý                      # Push a list in the range [0,18]
   °                     # Take 10^n of each value in this list
    'L«                 '# Append an "L" to each integer
       “  ||î® == “ì     # Prepend dictionary string "  || input == " to each
”„‡€‚—¿”                 # Push dictionary string "Power Of One"
        á                # Only keep the letters / remove the spaces: "PowerOfOne"
“‚Æ£‹ÒŒ€ˆÿ(ƒÈî®) {\n „Á“ # Push dictionary string "public static boolean isÿ( long input) {\n  return",
                         # were the `ÿ` is automatically filled with the "PowerOfOne" string
    š                    # Prepend it in front of the earlier list
     »                   # Join the list by newlines
…;\n}«                   # Append ";\n}" at the end
„(                       # Push string "( "
   ¬                     # Push its first character (without popping): "("
    :                    # Replace the "( " with "("
„||ð.;                   # Replace the first "||" with " "
                         # (after which the result is output implicitly)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why “  ||î® == “ is "  || input == "; ”„‡€‚—¿” is Power Of One; and “‚Æ£‹ÒŒ€ˆÿ(ƒÈî®) {\n „Á“ is "public static boolean isÿ( long input) {\n  return".


text:
Tips for golfing in Jelly
Jelly is a tacit, golf-oriented programming language by our very own Dennis. It’s popping up in answers here more and more often, beating other golf-y languages like Pyth and CJam, both by using its own code page and its powerful chain system to succinctly express programs.
Let’s collect some useful tips for golfing in Jelly. (As always, one tip per answer, please!)

Makes me wonder if Jelly is still too much in flux for this to generate content that will be useful in the long run, but the best person to answer that is probably Dennis.

I think there are already plenty of tips that should make sense no matter what changes happen in the language. Tips for golfing in Pyth has the same problem, I suppose, but it has passed the test of time reasonably well so far; answers are usually updated whenever they no longer apply because of a language change, albeit with some delay.

Here's a nice tip: become @Dennis's apprentice. Then, you will really be good at golfing jelly.

@Lynn I love how you say our very own Dennis. It's like we're all one big family :D.

This thread in Jelly's GitHub issues on how to actually type Jelly code page characters is probably worth a tip or two: https://github.com/DennisMitchell/jelly/issues/6 I don't have access to a Windows machine, though, so I don't feel confident writing up those bits.

String compression

If you're looking for a more optimized/automatic string compressor, try this one.

Try it online!
A compressed string looks like “...», where the dots are a chunk of base-250-encoded data. The decompression algorithm is a bit complicated: the chunk is interpreted as a “mixed-base” integer, with divmod breaking off various parts of this integer and constructing a string out of them.
I’ve created a little Python 3 interface to compress Jelly strings:
import dictionary
code_page = '''¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«»‘’“”'''

class Compress(list):
    def character(self, c):
        if c in '\n\x7f¶':
            o = 95
        elif ' ' <= c <= '~':
            o = ord(c)-32
        else:
            raise ValueError(c + " is neither printable ASCII nor a linefeed.")
        self += [lambda z: 3*z+0, lambda z: 96*z+o]; return self
    def string(self, s):
        for c in s: self.character(c)
        return self
    def dictionary(self, w):
        ts = bool(self)
        if w[:1] == ' ': w = w[1:]; ts = not ts
        dct = dictionary.short if len(w) < 6 else dictionary.long
        W, sc = (w, 0) if w in dct else (w[:1].swapcase() + w[1:], 1)
        if W not in dct: raise ValueError(w + " isn't in the dictionary.")
        f = ts or sc; j = (2 if sc else 1) if ts else 0; i = dct.index(W)
        self += [lambda z: 3*z+2, lambda z: 3*z+j] if f else [lambda z: 3*z+1]
        self += [lambda z: 2*z+int(len(w) < 6), lambda z: len(dct)*z+i]
        return self
    def go(self):
        compressed = []; z = 0
        for f in self[::-1]: z = f(z)
        while z:
            c = z % 250
            if c == 0: c = 250
            z = (z - c) // 250
            compressed.append(code_page[c - 1])
        return '“{0}»'.format(''.join(compressed[::-1]))

Use the compressor as follows.
print(Compress()
      .dictionary('public')
      .dictionary(' static')
      .dictionary(' boolean')
      .string(' is')
      .dictionary('Power')
      .string('Of')
      .dictionary('Ten')
      .string('(')
      .dictionary('long')
      .dictionary(' input')
      .string(') {\n ')
      .dictionary(' return')
      .string('\n   ')
      .dictionary(' input')
      .string(' ==')
      .go())

Compress is a string builder:

.string(s) will insert raw, printable ASCII characters into the string.
(Each character costs about 0.827 compressed bytes.)
.dictionary(w) will look up a string in Jelly’s built-in dictionaries. You may begin the string with a single space, if you want one. If this needs to deviate from the normal string-adding behavior, or flip the capitalization of a dictionary word, it’ll add flags accordingly.
(Costs about 1.997 bytes for short words, 2.433 bytes for long words; if there are flags, add 0.199 bytes.)

That's useful! I grew a little tired of compressing these by hand...

@Dennis Could this be included in Jelly itself, so we wouldn't have to copy it from here every time?

@Pietu1998 As an atom or something else?

@Dennis As a utility script in the repository.

@Dennis: It crosses my mind that it'd make sense for Ṙ to compress its output in this way if doing so is shorter than outputting a "normal" string.

Note: On mac, you'll need to import sys. You'll also need to replace the print statement to output the compressed text with sys.stdout.buffer.write(Compress().go().encode(utf-8).

This is giving me issues; it says module 'dictionary' has no attribute 'short'.

Probably requires something in Jelly.

This is part of what became the Jelly wiki tutorial.

Chains
(This is sort of a follow-up to Tacit programming.)
How does Jelly evaluate a chain? As explained before, there are three cases to consider: whether this chain was called niladically, monadically, or dyadically.

1. Niladic chains
These are the easiest of the bunch. To evaluate a niladic chain that starts with a nilad, like α f g h, evaluate the monadic chain f g h at that nilad α. (Caveats: if the whole chain is empty, 0 is returned instead. If α isn’t a nilad, replace use α=0 instead.)
For example, 4½ is just ½ evaluated at 4, which is 2.

2. Monadic chains
Monadic chains are broken down from left to right, until there are no links left to consider. Also, we’re passed some argument ω here. There are two questions to answer:
What’s the starting value for this left-to-right evaluation?

If our chain starts with a nilad α, and is followed by zero or more monads (like ½), dyad-nilad pairs (like +2), and nilad-dyad pairs (like 4*): we start by evaluating α, and then consider the rest of the chain.
Otherwise, we start from the argument passed to this chain, ω, and consider the entire chain.

How do we walk down the chain?
Let’s call V the current value – initially, it’s the value described above, but it gets update as we go through the chain – and denote

nilads using digits,
monads using lowercase letters,
dyads using operator symbols +, ×, ÷.

Then the following patterns are matched against, from top to bottom:
                                 ┌───────────┬─────────┐
                                 │ old chain │ new V   │
                                 ╞═══════════╪═════════╡
                                 │ + × 1 ... │ (V+ω)×1 │ *
                                 │ + f ...   │ V+f(ω)  │
                                 │ + 1 ...   │ V+1     │
                                 │ 1 + ...   │ 1+V     │
                                 │ + ...     │ V+ω     │
                                 │ f ...     │ f(V)    │
                                 └───────────┴─────────┘
      (* Only if `...` consists of monads, dyad-nilad pairs, and nilad-dyad pairs.)

Let’s try this out on the chain +²×.

+ isn’t a nilad, so we start out at V = ω.
Then, we chop off +², matching the second pattern, and get V = ω+ω².
Then, we chop off ×, matching the fifth pattern, and get V = (ω+ω²)×ω.
The chain is now empty, so (ω+ω²)×ω is our final result.

3. Dyadic chains
These are basically like monadic chains, but this time, there are two arguments, λ (left) and ρ (right).
What’s the starting value?

If the chain starts with three dyads like + × %, we start at λ+ρ, and consider the chain × % ... next.
Otherwise, we start from λ, and consider the entire chain.

How do we walk down the chain?
This time, the patterns are
                                 ┌───────────┬─────────┐
                                 │ old chain │ new V   │
                                 ╞═══════════╪═════════╡
                                 │ + × 1 ... │ (V+ρ)×1 │ *
                                 │ + × ...   │ V+(λ×ρ) │
                                 │ + 1 ...   │ V+1     │
                                 │ 1 + ...   │ 1+V     │
                                 │ + ...     │ V+ρ     │
                                 │ f ...     │ f(V)    │
                                 └───────────┴─────────┘
      (* Only if `...` consists of monads, dyad-nilad pairs, and nilad-dyad pairs.)

Let’s try this out on the chain +×÷½.

The chain starts with three dyads, so we start at V = λ+ρ, and throw away the +.
Then, we chop off ×÷, matching the second pattern, and get V = (λ+ρ)×(λ÷ρ).
Then, we chop off ½, matching the sixth pattern, and get V = sqrt((λ+ρ)×(λ÷ρ)).
The chain is now empty, so we’re done.

So is this becoming more of a Jelly tutorial than tips for golfing in it? ;)

I suppose so. If the language is very tricky to understand, I think “how does any of this even work?!” is a good tip ^^ I do intend to eventually move on to non-obvious tricks and ways to save bytes. If this is out of place here, I could move it to GitHub, or (if Dennis likes it) the Jelly repo.

Special-cased numeric values
Here are some special cases for Jelly's numerics parser:

- evaluates to -1
. evaluates to 0.5
ȷ evaluates to 1000 (ȷ is for scientific notation, e.g. 2ȷ6 is 2000000)
ı evalulates to 1j (ı is for complex numbers, e.g. 2ı3 is 2+3j)

It's also worth noting that something like 4ı is actually 4+1j, rather than 4.
You can mix and match these, e.g.:

-. is -0.5 and -ȷ is -1000
-ı is -1+1j, ı- is -1j and -ı- is -1-1j
.ȷ is 500.0
.ı is 0.5+1j, ı. is 0.5j and .ı. is 0.5+0.5j
ȷı is 1000+1j, ıȷ is 1000j and ȷıȷ is 1000+1000j

Note that ȷ- is 0.1, but that doesn't save any bytes over .1. Then there's also the following, which can already be done in the corresponding number of bytes by using the builtin variable for 10 (⁵), but might be useful in the rare case that the builtin is unavailable or to save on needing to use ¤:

ȷ. is sqrt(10) ~ 3.162277, .ȷ. is sqrt(10)/2 ~ 1.5811 and ȷ-. is 1/sqrt(10) ~ 0.31162

Optimal string compressor
Recently I asked Erik the Outgolfer to add the optimized string compressor to JHT references page, but they said that

sorry, but that compressor doesn't seem to be fully implemented
  it says “ugtestslug” is the shortest possible for ugtestslug, while “#ṀȮụḄPƇ» also does the job

So I decide to implement the optimal string compressor.
Simple approach, but guarantee to find the smallest possible value (and hence byte count)
Take input from stdin, output to stdout. Just like the original compressor, ¶ or
 (literal newline character) can be entered as newline.
Trying to run it with a lot of punctuation (for example, input ¶-----¶) will output the uncompressed string.
Of course, a lot of credit for this goes to Lynn for creating the original compressor.

This fails to correctly compress strings with trailing spaces. For example, every string consisting entirely of spaces gets compressed to “». (This is arguably a bug in Jelly’s compression design.)

@AndersKaseorg It has been so long I can't remember what it's about, but if you make a better one I'll edit the post to link to it

@AndersKaseorg Yes, this is a bug with Jelly's string compression, not with this compressor. Strings with trailing spaces, when compressed into the base-250 number, converts those trailing spaces into leading zeros (see the decompressed += code_page[code + 32] line in the sss decompressor), which have no effect on the number (as 015 = 15)

@cairdcoinheringaahing But ideally the compressor should have fallback code to work around this bug, like it has for the “lot of punctuation” case.

Optimised string compressor
Try it online!
Lynn's post details what compressed strings are exactly, along with having a compressor that will produce these compressed strings. However, while tinkering around with a program in Jelly, I found it tiring to have to combine .dictionary and .string along with the correct placements of spaces and so on and so forth, in order to achieve the shortest possible string.
Therefore I decided to create an extension to Lynn's script that would take user input, and find the shortest way it can be compressed without the user having to do any work. The script is quite long, and so I've added in a TIO link, rather than the code itself.
The way the program works is by compressing using 3 different methods and determining which is shortest:

Method 1 simply encodes each byte of the input at a time, which tends to produce the longest result, as compared to the others. Even when the input is very short, it still manages to create rather long alternatives. For example, the shortest way that test can be compressed is “¡ḌY», whereas this method returns “¡⁷ƑKʂ» (2 bytes longer). As a general rule, this only works if the string is less than 4 characters long

The second method breaks the string into words and punctuation, as the two are added to the compressor in different ways. Words that are part of the dictionary are added with the .dictionary method of Lynn's code, which compresses them more than if they were simply added by code points. Punctuation however has to be added by code point as, unfortunately, they aren't part of the dictionary.
Punctuation includes spaces, which is where method number 3 comes into play, but first and evaluation of method 2: let's compare methods one and two compressing the string Hello, World! (contains words, punctuation and spaces, so is perfect). Compressing character by character results in the final string of “ŒCdẉa÷¹ṂȤƓ(Ẋ)» (15 bytes long), which, as it turns out, is longer than the easier way to output Hello, World!: “Hello, World!. Now lets take a look at method two. This produces the compressed string “Ọƥ⁷Ƭė3⁶» which weighs in at 9 bytes, a great improvement over the old one. However, the shortest Hello, World! program in Jelly is 8 bytes, so something can be improved

Here comes method 3, making it even shorter. As expected, output for Hello, World is, of course, “3ḅaė;œ» which is the shortest possible program. So what does method 3 do, that method 2 doesn't? Method 3 combines lone spaces into leading spaces, which the Jelly decompressor has a flag for. In the code for both the compressor and the decompressor, you can see code like if flag_space: word = ' ' + word, showing that leading spaces are a) supported and b) byte-saving. Therefore, the string splitter from method two is adapted so that spaces by themselves are combined into the string directly after is, to create leading strings. This means that Hello, World! is parsed as ["Hello", ",", " World", "!"], which when compressed is only 6 bytes (8 when including delimiters). This is almost always the shortest method of compression, excluding the "extension" I added,

This is the bulk of the program, but there are a few more options that help it compress data even more.

The program checks whether or not each compressed version is correct, by using Dennis' sss decompressor that Jelly uses (go straight to the source)
You can see all different compressed strings by making the first command line argument --debug, which, rather than simply showing the shortest compressed string, shows all 3 along with a "This is the shortest" copy
The program handles "non-words"

Non-words
I started work on Lynn's compressor after seeing this message, took a crack at it and got frustrated at the fact that I couldn't find the shortest way to compress it (it's 29 or 32 bytes for the record). However, while testing my improvements, I found that words such as knowns aren't in Jelly's dictionary. Therefore, I set out to find a way to compress these "non-words" in the shortest Jelly code possible.
I created a function (trim) that splits the string as a point where at least one of the parts of the string are words. For example knowns would be split into ["known", "s"] and have the program add the first word via a dictionary add (.dictionary) and the second part of the word via a .string call. But this still leaves two edge cases: strings which have no words in them (such as ajdl) and non-words which have words at the end, such as abctest, which wouldn't get split by the trim function.
As there is no way of finding words in a string which has no words in it, the simplest and shortest way to handle these is by adding them in character by character via a .string call. So ajdl would get added by .string('ajdl'). Whereas non-words which end with recognised words, essentially implements the trimmer but in reverse, and applying .dictionary and .string the other way round to the forwards trimmer.
As it turns out, trimming the string, either from the start or the end is, of course, shorter than adding each character to the compressor, as demonstrated by an input of abctest this string, which produces a debug output of
Original        : abctest this string

Optimised       : “¡J+v(p⁸ụƘ$,»
Seperate spaces : “Ç⁴ṭḍµḄ7oeṂdḷp»
No trimmer      : “¤ɦ?Ɓ¢#fḲOạ⁾¶ɼȥƬ»
All characters  : “µẓþ"Y7_ḣṗḢ))9Þ⁴⁺Ẉ²)ɱ»
Non-compressed  : “abctest this string
Shortest        : “¡J+v(p⁸ụƘ$,»
=====

The different between the optimal output (which uses the trimmer) and the one which doesn't is a whopping (for Jelly) 4 bytes. Finally, there are occasions where the string itself is shorter than any compressed version, which has now been factored in.
Of course, a lot of credit for this goes to Lynn for creating the original compressor

Should this be deleted now that we have https://codegolf.stackexchange.com/a/151721/39328?

@lirtosiast By that same argument, you could say that this post should be deleted. Its doing no harm, and is a perfectly valid answer, there is no reason to delete it, simply because there is a better answer.

You can use superscript three to nine (³⁴⁵⁶⁷⁸⁹) to golf some usually used
values, but this depends on the amount of command line arguments, and in case of links, on the arguments of the links.

³ returns 100, and works only if there's no input.
⁴ returns 16, and works only if there's at most one input.
⁵ returns 10, and works only if there's at most two inputs.
⁶ returns a space if there's at most three inputs.
⁷ returns a new line if there's at most four inputs.

If there are five inputs, however, you're out of luck.
Recently, a new version of the language lowered the value of ³ to 100, and introduced some new atoms that return values or (for links) their arguments.

⁸ returns a blank list everywhere except links which have a left argument passed to them.
⁹ returns 256 everywhere except links which have a right argument passed to them.

If you're in a link, and have arguments from both sides passed to it, however, you're out of luck.

Actually, unused inputs are filled with default values! Such convenience!

Abuse string bugs
Credits go to Adnan for taking advantage of this first in Write a program to elasticize strings.
Jelly is supposed to get character arithmetic one day, but until that happens, we can take advantage of the fact that Python overloads most arithmetic operators and that Jelly does no type checking.
For example
“abcd”Ḥ

isn't supposed to do anything useful right now, but since Ḥ (unhalve) is implemented as
lambda z: z * 2

and arithmetic atoms vectorize at depth 0 (i.e., they operate on numbers or characters), the above Jelly code yields
['aa', 'bb', 'cc', 'dd']

Careful that this produces actual Python strings (a type Jelly isn't supposed to have), so this won't be usable in all situations.
Likewise, +/ can be useful to concatenate strings, with the same caveats.

So if in the future when character arithmetic is added, will you add type overloads for strings and other non-numeric types to those atoms?

More or less. I'm planning to create a numeric type that is internally a number but has a character flag. That flag would only affect printing; the characters could be used instead of integers everywhere.

S can never be useful to concatenate strings, it will attempt to add 0 to them.

@EriktheOutgolfer Right, pesky base case. +/ works though.

@Dennis Yeah, I've pretty much won a challenge as of now with +/.

Why can't you just do ;/ to concatenate strings, in all cases?

;/ concatenates rows, +/ concatenates columns.

@Dennis Also as of a few days ago Ẏ replaces ;/.

This is part of what became the Jelly wiki tutorial.

Multi-chain links
Remember when I wrote that you define a link by making a chain of other links? I wasn’t telling the whole truth: in reality, it’s a two-layer process. A link is a chain of chains, and by default, the outer chain simply has unit length.
Consider this program:
C+H

That’s complement plus half. It takes an input value n and calculates (1-n)+(n/2). Not too exciting, I know. But the structure is really like this:

The link we wrote is, itself, actually a chain containing a single chain.
Suppose that we want to calculate (1-n)+(1-n)(n/2) instead. The dyadic chain +× would work: by the chaining rules, it calculates λ+(λ×ρ), which looks a lot like what we need. However, simply replacing + by +× in our program won’t do: C+×H is a 1,2,2,1-chain – complement, then add (the argument), then multiply by half – computing ((1-n)+n)×(n/2).
We want Jelly to treat +× as a unit, and make a 1,2,1-chain of the sub-chains C, +×, and H. Multi-chain links let us do just that! To construct them, we use the chain separators øµð: in the image above, they would introduce a new blue rectangle, of arity 0, 1 and 2, respectively. In our case, we can group the chains the way we want by writing Cð+×µH:

There’s no way to nest these things even further. You’ll have to define multiple links, instead.

How did you make those charts, out of curiosity?

I drew them by hand in Paint.NET :)

Wow! Impressive! This would be cool for hard Jelly programs, like a tool that does this. (Akin to HexagonyColorer or whatever it's called)

This is part of what became the Jelly wiki tutorial.

Tacit programming
Jelly is a tacit programming language. This means you define links (functions) by composing existing links into a chain, without explicitly talking about the arguments involved. Which way the arguments “flow” through this composition is defined by the pattern the links are arranged in. An example of this will be given soon, but first we’ll need to introduce some concepts.
The arity of a link is a very crucial concept. All of the atoms – the built-ins, like + and ½ – have fixed arities. Links are sorted into three categories, depending on their arity:

Nilads take no arguments (arity 0); other than some I/O and stateful commands, they mostly represent constant values. For example, the literal 3 is a nilad.

Monads take one argument (arity 1). (There’s no connection to functional programming monads here.) For example, ½ (square root) is a monad.

Dyads take two arguments (arity 2): a left and a right argument. For example, + is a dyad.

(Using adjectives, we say that a link is niladic, monadic, or dyadic.)

So what’s the arity of the links we define when writing a program? By default, they are variadic – that is, it’s up to the caller to specify how many arguments to use, and in the case of the main link, it depends on how many arguments the program is passed.
As an example, +½ is a chain of + (addition) and ½ (square root). As the respective arities of the elements of this chain are 2 and 1, we call it a 2,1-chain. The interpreter has specific rules for breaking down chains, based on their arities: those rules dictate that, given an input n, this new link computes n + sqrt(n). (You can read +½ as “... plus its square root.”)
Jelly programming, then, is essentially the art of learning these rules well, and composing clever chains that get the job done, tacitly.

Are there triads?

Nope! I’m curious to see how Dennis will implement, say, string replacement, which is a bit inherently triadic (replace(str, old, new)).

I don't know Jelly, but I do know a bit of J. Maybe it could be, say, string (operator) (list), where (list) is a binary list old, new. That would make sense, jelly having a built-in pair operator. Under that scheme, though, it would be two bytes for the operator.

Wait... ½ is square root? Why isn't ½, um... half? Why not   √ for square root? :(

@Cyoce because H is already half, obviously :P

@CᴏɴᴏʀO'Bʀɪᴇɴ that brings up an interesting point: how does Jelly do the conditional (ternary) operation? The pair trick can't work, because conditionals should be lazily-evaluated to be able to govern control flow as well.

@Cyoce using ?

Integer compression
String compression is useful when producing text in English, but if you need to compress other sorts of data, it's fairly ineffective. As such, most of the time you want to store a large fixed constant in your program, it's best to store it as an integer.
Now that Jelly has its own code page as a constant, the compression algorithm for integers is most simply expressed in Jelly itself:
ḃ250ịØJ”“;;”’ṄV

Try it online!
(The above program also contains a check to show the value that the integer decompresses to.)
In addition to just using an integer as an integer, you can also use it to create a string via doing base conversion on it, then indexing into an alphabet of characters. The ṃ atom automates this process, and is fairly useful because it can describe the entire process of decompression (other than the alphabet being decompressed into) in a single byte.

This is part of what became the Jelly wiki tutorial.

Program structure
Each line in a Jelly program is a link definition. Links are basically functions. The bottom line represents “main”: it's the link that gets evaluated using the arguments passed on the command line.
All links but the last one, then, are function definitions: you can refer to them using actors. For example, ç is “the link above this one, as a binary operator (dyad)”. Consider this example program, which computes the square of the sum of its arguments:
+
ç²

This is sort of like the pseudocode:
define f:
    the built-in link +
define main:
    apply the dyad f
    square the result

If TMTOWTDI, pick the one that fits your chain.
One of the advantages of a tacit language is that you usually can get away without using variable references. However, this works only if the links in your chain have the right arities.
For example, the straightforward way of taking the sum of all arrays in a 2D array is
S€

which maps the sum atom over all elements of the array.
Now say you have a monadic chain that consists of the atom
*

which maps each x of a 2D array to xx. For example, for A = [[1, 2], [3, 1], [2, 3]], calling the chain would yield [[1, 4], [27, 1], [4, 27]].
Now, we want to take the sum of each pair. Unfortunately,
*S€

doesn't work since * doesn't act like a hook anymore (using A itself as right argument), but as a fork, meaning that S€ gets applied to A first, and the result is the right argument of *.
Fixing this is easy enough:
*¹S€
*⁸S€

Both produce the desired result: *¹ is a fork where ¹ is the identity function, and *⁸ is an atop, where ⁸ is a reference to the chain's left argument (A).
However, there's a way to save a byte! The atop ḅ1 (convert from unary to integer) also computes the sum of each array in AA, but unlike S€, ḅ is a dyadic link.
The chain
*ḅ1

returns [5, 28, 31] (as desired); since ḅ is dyadic, * hooks instead of forking

"The atop ḅ1"?

Atop is J terminology. In Jelly, it is a type of chain that operates directly on the last return value, so it is executed on top of the previous link of the chain.

Another reason to never try to learn this language...:P

I felt the same way about J/APL, but after a while it feels as natural as any other language.

Use outer products to create useful integer matrices
Here is a gist I have created of this post with slightly nicer HTML table formatting.
The outer product quick þ can be attached to dyads and causes the dyad to act on each pair of elements in its left and right arguments. It is shorthand for €Ð€. For example if we had the code [1,2]+€Ð€[0,10] we could shorten it to [1,2]+þ[0,10]  and they would both yield [[1,2],[11,12]]. I will refer to a dyad with þ applied (such as +þ) as an outer product dyad.
When an integer is one of the arguments of an outer product dyad, Jelly takes the range of that number first then uses the result as the argument. Knowing this, the above example can be further shortened to 2+þ[0,10]. This is true for both the left and right arguments of an outer product dyad.
Some outer product dyads when acting monadically on an integer yield certain integer matrices that can be useful in golfing (especially ASCII art challenges) but would take many bytes to otherwise construct. For example =þ when applied to an integer n yields an n×n identity matrix. Try =þ online!
Below is a table of dyads and the type of matrices they yield when turned into outer product dyads and acted monadically on an integer. Dyads listed in the same row will yield the same matrices. There are dyads I haven't included in the table like &, |, %, w, ẇ and ḍ that also produce integer matrices but their patterns are not as simple and would likely be useful in fewer situations. Try wþ online!

Dyad
Resulting matrix
Example

=, ⁼, i or ċ
Identity matrix.
1 0 00 1 00 0 1

>
Elements above diagonal are 1, all other elements are 0.
0 1 10 0 10 0 0

<
Elements below diagonal are 1, all other elements are 0.
0 0 01 0 01 1 0

n or ⁻
Diagonal elements are 0, off diagonal elements are 1.
0 1 11 0 11 1 0

a, ị, ṛ or ȧ
Row index of each element.
1 1 12 2 23 3 3

o, ḷ or ȯ
Column index of each element.
1 2 31 2 31 2 3

_
Main diagonal is 0, upper diagonals are 1, 2..., lower diagonals are -1, -2...
0  1  2-1  0  1-2-1 0

_@
Main diagonal is 0, upper diagonals are -1, -2, etc., lower diagonals are 1, 2, etc. The only dyad in this table that doesn't have a one byte alternative that results in a transposed matrix is _.
0 -1-21 0 -12 1 0

ạ
Main diagonal is 0, upper and lower diagonals are 1, 2, 3...
0 1 21 0 12 1 0

+
Row index plus column index.
2 3 43 4 54 5 6

«
Minimum of row and column indices.
1 1 11 2 21 2 3

»
Maximum of row and column indices.
1 2 32 2 33 3 3

Now that SE Markdown supports tables, I've edited the table from your gist into the answer. Feel free to revert

Consider using i rather than e

e: If x occurs in y, then 1, else 0
i: Find the first index of element y in list x, or 0

The key thing here is that e and i take arguments in opposite orders. This can be exploited in two main cases:

The question allows you to return an inconsistent truthy value, and your answer works by generating a list and checking if the argument is in this list
For example, checking if a number is a Fibonacci number takes 5 bytes using e:
RÆḞe@

But only 4 using i, assuming any truthy value may be returned:
RÆḞi

Using a filter quick (Ƈ or Ðḟ). Let’s say you have generated a list of lists and want to keep only those where the input is (or is not) contained in it. As i returns a truthy value if the right argument is in the left, you can set up a dyadic link iƇ to remove lists that don’t contain the left argument, saving a byte over e@Ƈ

Generally, this tip works best for answers that generate a list, then test the left argument for membership in some way, allowing you to avoid the @ quick or using a “grouper” like $ or Ɗ

Jelly IDE/Debugger
After struggling a lot with Jelly's codepage, parsing, error messages and debugging, I decided to build a IDE/debugger for Jelly. This has been in the works for a very long time, but I finally decided to finish most of the features.

Download: https://gitlab.com/PurkkaKoodari/jellyide

Installation instructions are in the repo README. You may need to install the DejaVu Sans Mono font (included) to your system to allow Tkinter to find it.
Features
Tkinter-based GUI
Run as python -m jellyide [filename].

Code editor
UTF-8 and Jelly codepage support
Code suggestion with keyword search (press Ctrl+Space)
Windowed output console
Jelly runs in a separate thread and can be killed/restarted
Notably missing: command line arguments

Augmented Jelly CLI with most of the features
Run as python -m jellyide.jelly [--opts] <jelly args...>. Use --help for more instructions.
Supports debugging, nice stack traces and everything the Jelly CLI supports.
Code visualization (links, quicks, chains, arities)
Only in the GUI, determines the links used and visualizes how they are parsed and executed.

Block colors indicate arity of link/chain
Bunched-together blocks indicate chain execution steps (+1, 1+, +F and so on)

Step-by-step debugging

Break/continue (via GUI or using Ctrl-C in CLI)
Start program with stepping (via GUI or --step in CLI)
Step to next entry/return of an atom/quick
Step to return of current atom/quick
Shows args or return value in console

--- PAUSED ---
Ḥç€
^^^
left arg: [1, 2, -1, -2]
right arg: 3
[s]tep, step to [r]eturn, [c]ontinue, [q]uit?
--- PAUSED ---
Ḥç€
^
arg: [1, 2, -1, -2]
[s]tep, step to [r]eturn, [c]ontinue, [q]uit?
--- PAUSED ---
Ḥç€
^
return: [2, 4, -2, -4]
[s]tep, [c]ontinue, [q]uit?
--- PAUSED ---
Ḥç€
 ^^
left arg: [2, 4, -2, -4]
right arg: 3
[s]tep, step to [r]eturn, [c]ontinue, [q]uit?
--- PAUSED ---
ç€
^
left arg: 2
right arg: 3
[s]tep, step to [r]eturn, [c]ontinue, [q]uit?

Error stack traces with Jelly code locations
I'll let the results speak for themselves. I'm sure you've seen Jelly's built-in error messages.

in Æs
,Æs
 ^^
arg: -2

in ,Æs$
,Æs$×
^^^^
arg: -2

in ,Æs$×
,Æs$×
^^^^^
left arg: -2
right arg: 3

in ç
ç€
^
left arg: -2
right arg: 3

in ç€
Ḥç€
 ^^
left arg: [2, 4, -2, -4]
right arg: 3

in Ḥç€
Ḥç€
^^^
left arg: [1, 2, -1, -2]
right arg: 3

ValueError: n must be a positive integer

There are several nonobvious ways to check properties of an argument using Ƒ. Below are a few. I left out plenty of uses of this quick (E.g. AƑ, ŒuƑ, 3Ƒ) because they are already the most straightforward methods of achieving their behavior.
OƑ  Is number?
ỌƑ  Is character? (errors on negative numeric input)
ḂƑ  Between 0 and 2? 0<=x<2 (python). <2aAƑƊ or of course ⁼Ḃ$ in Jelly.
ḞƑ  Is integer?
UƑ  Like `ŒḂ`, but checks if all sublists of depth 1 are palindromes.
ṠƑ  Is one of -1, 0, 1? (e-r1¤$)

Feel free to edit this to add more interesting cases.

You may want to try an online editor Jelly Balls designed to easily build code in Jelly Language.
The features include:

Command palette with all atoms and syntax characters organized by type
Online parser recognizing literals and 2-byte atoms in the code
Simplified in-browser Jelly interpreter to run your Jelly code on the webpage in javascript
Direct links for transferring the code into TIO or another Jelly Balls session
Automatic hints
Optimised for mobile devices

Give it a try: https://jellyballs.github.io

Detailed trace report showing arguments and results of every executed step

Code report showing description of every step

Recipes page with Jelly examples

Interactive code page of 256 Jelly characters

Yepp, would better fit Where to find an online testing environment for specific programming languages?.

I think a link to an IDE that lets you write Jelly without a custom keyboard layout is a rather useful tip. Many Jelly beginners have struggled with that.

The various uses of ị
ị, the "index into" command has some extended capabilities beyond the standard index into command in most languages. For example:

Command
Functionality
TIO

0ị
Return the last element
Try it online!

Lị
Return the last element
Try it online!

.ị
Return the last and first elements
Try it online!

-.ị
Return the last two elements
Try it online!

1.ị
Return the first two elements
Try it online!

Ø½ị
Return the first two elements
Try it online!

JŻị
Prepend the final element
Try it online!

JŻ‘ị
Append the first element
Try it online!

Ø+ị
Return the first and penultimate elements
Try it online!

L‘Hị
Return the middle elements  (2 if even length, else 1)
Try it online!

L‘HịṢ
Return the median of the array
Try it online!

Tị
Remove all falsey elements
Try it online!

¬Tị
Remove all truthy elements
Try it online!

Mị
Remove all but the maximal elements
Try it online!

Chain shapes
Here are all the possible chain shapes of nilads 1234, monads FGHJ and dyads +*%& up to length 4.
Each is given with its monadic and dyadic behaviors in a non-tacit Ruby-like syntax, where (x+y).F applies/calls F on x+y.
For example, we wish to parse P+€Tọ. We know that P is a monad, +€ is a dyad, T is a monad, and ọ is a dyad. So we look up F+G* in the below table and see that it's ((a.F+a.G)*a), and we can understand the program as ((a.Product +€ a.Truthy) ọrder a).
Code   Monadic (arg=a)     Dyadic (args=x,y)
==================================================
   1   1                   1
   F   a.F                 x.F
   +   (a+a)               (x+y)
  1+   (1+a)               (1+x)
  FG   a.F.G               x.F.G
  F+   (a.F+a)             (x.F+y)
  +1   (a+1)               (x+1)
  +F   (a+a.F)             (x+y).F
  +*   ((a+a)*a)           (x+(x*y))
 1+F   (1+a).F             (1+x).F
 1+*   ((1+a)*a)           ((1+x)*y)
 F1+   (1+a.F)             (1+x.F)
 FGH   a.F.G.H             x.F.G.H
 FG+   (a.F.G+a)           (x.F.G+y)
 F+1   (a.F+1)             (x.F+1)
 F+G   (a.F+a.G)           (x.F+y).G
 F+*   ((a.F+a)*a)         (x.F+(x*y))
 +1F   (a+1).F             (x+1).F
 +1*   ((a+1)*a)           ((x+1)*y)
 +FG   (a+a.F).G           (x+y).F.G
 +F*   ((a+a.F)*a)         ((x+y).F*y)
 +*1   ((a+a)*1)           ((x+y)*1)
 +*F   ((a+a)*a.F)         (x+(x*y)).F
 +*%   (((a+a)*a)%a)       ((x+y)*(x%y))
1+2*   (2*(1+a))           (2*(1+x))
1+FG   (1+a).F.G           (1+x).F.G
1+F*   ((1+a).F*a)         ((1+x).F*y)
1+*2   ((1+a)*2)           ((1+x)*2)
1+*F   ((1+a)*a.F)         ((1+x)*y).F
1+*%   (((1+a)*a)%a)       ((1+x)*(x%y))
F1+G   (1+a.F).G           (1+x.F).G
F1+*   ((1+a.F)*a)         ((1+x.F)*y)
FG1+   (1+a.F.G)           (1+x.F.G)
FGHJ   a.F.G.H.J           x.F.G.H.J
FGH+   (a.F.G.H+a)         (x.F.G.H+y)
FG+1   (a.F.G+1)           (x.F.G+1)
FG+H   (a.F.G+a.H)         (x.F.G+y).H
FG+*   ((a.F.G+a)*a)       (x.F.G+(x*y))
F+1G   (a.F+1).G           (x.F+1).G
F+1*   ((a.F+1)*a)         ((x.F+1)*y)
F+GH   (a.F+a.G).H         (x.F+y).G.H
F+G*   ((a.F+a.G)*a)       ((x.F+y).G*y)
F+*1   ((a.F+a)*1)         ((x.F+y)*1)
F+*G   ((a.F+a)*a.G)       (x.F+(x*y)).G
F+*%   (((a.F+a)*a)%a)     ((x.F+(x*y))%y)
+12*   (2*(a+1))           (2*(x+1))
+1FG   (a+1).F.G           (x+1).F.G
+1F*   ((a+1).F*a)         ((x+1).F*y)
+1*2   ((a+1)*2)           ((x+1)*2)
+1*F   ((a+1)*a.F)         ((x+1)*y).F
+1*%   (((a+1)*a)%a)       ((x+1)*(x%y))
+F1*   (1*(a+a.F))         (1*(x+y).F)
+FGH   (a+a.F).G.H         (x+y).F.G.H
+FG*   ((a+a.F).G*a)       ((x+y).F.G*y)
+F*1   ((a+a.F)*1)         ((x+y).F*1)
+F*G   ((a+a.F)*a.G)       ((x+y).F*y).G
+F*%   (((a+a.F)*a)%a)     ((x+y).F*(x%y))
+*1F   ((a+a)*1).F         ((x+y)*1).F
+*1%   (((a+a)*1)%a)       (1%(x+(x*y)))
+*FG   ((a+a)*a.F).G       (x+(x*y)).F.G
+*F%   (((a+a)*a.F)%a)     ((x+(x*y)).F%y)
+*%1   (((a+a)*a)%1)       (((x+y)*y)%1)
+*%F   (((a+a)*a)%a.F)     ((x+y)*(x%y)).F
+*%&   ((((a+a)*a)%a)&a)   (((x+y)*(x%y))&y)

The table demonstrates how the same program can parse very differently depending on the number of arguments. The following program has a *1 step in it when parsed monadically, but 1% when parsed dyadically:
+*1%   (((a+a)*1)%a)       (1%(x+(x*y)))

List commands and literals
If you attempt to use many of the non-vectorizing list commands on a literal n or a list of literals z, the list command will first convert to a list of some sort and then carry out the command on that list.
These commands appear use calls to the iterable function in jelly.py.
def iterable(argument, make_copy = False, make_digits = False, make_range = False):
    the_type = type(argument)
    if the_type == list:
        return copy.deepcopy(argument) if make_copy else argument
    if the_type != str and make_digits:
        return to_base(argument, 10)
    if the_type != str and make_range:
        return list(range(1, int(argument) + 1))
    return [argument]

Here are some incomplete lists of what those list commands will do.
Wraps in a list
The simplest return from iterable to wrap the argument in a list, and return that to be processed by the function. This happens if the argument is not already a list, is a string, and iterable's arguments don't call for other methods.
-------------------------------------------------------------------------------
| Command | Description     | Process                       | Effect          |
-------------------------------------------------------------------------------
| F       | Flattens a list | 4953F -> [4953]F -> [4953]    | Same as W       |
-------------------------------------------------------------------------------
| G       | Format a list   | 4953G -> [4953]G -> [4953]    | Same as W       |
|         | as a grid       |                               |                 |
-------------------------------------------------------------------------------
| I       | Increments      | 4953I -> [4953]I -> <nothing> | Empty list      |
-------------------------------------------------------------------------------
| S       | Sums a list     | 4953S -> [4953]S -> 4953      | Same as ¹       |
-------------------------------------------------------------------------------
| Ṭ       | Boolean array,  | 4Ṭ -> [4]Ṭ -> [0, 0, 0, 1]    | n-1 zeroes,     |
|         | 1s at indices   |                               | 1 at end        |
-------------------------------------------------------------------------------
| Ụ       | Sort indices by | 4Ụ -> [4]Ụ -> [1]             | Yields [1]      |
|         | by their values |                               |                 |
-------------------------------------------------------------------------------
| Ė       | Enumerate list  | 4Ė -> [4]Ė -> [[1, 4]]        | Yields [[1, n]] |
-------------------------------------------------------------------------------
| Ġ       | Group indices   | 4Ġ -> [4]Ġ -> [[1]]           | Yields [[1]]    |
|         | by values       |                               |                 |
-------------------------------------------------------------------------------
| Œr      | Run-length      | 4Œr -> [4]Œr -> [[4, 1]]      | Yields [[n, 1]] |
|         | encode a list   |                               |                 |
-------------------------------------------------------------------------------

Convert to base 10
The functions here call iterable to converts to a number to a list of its digits D, and then run on those digits.
-------------------------------------------------------------------------
| Command | Description     | Process                      | Effect     |
-------------------------------------------------------------------------
| Q       | Unique elements | 299Q -> [2, 9, 9]Q -> [2, 9] | Unique     |
|         | ordered by      |                              | digits     |
|         | appearance      |                              | of n       |
-------------------------------------------------------------------------
| Ṛ       | Non-vectorized  | 4953Ṣ -> [4, 9, 5, 3]Ṛ       | Reverses D |
|         | reverse         | -> [3, 5, 4, 9]              |            |
-------------------------------------------------------------------------
| Ṣ       | Sort a list     | 4953Ṣ -> [4, 9, 5, 3]Ṣ       | Sorts D    |
|         |                 | -> [3, 4, 5, 9]              |            |
-------------------------------------------------------------------------

Convert to list with range
The functions here convert a number to the range R = [1 ... n], and then run on that range.
-----------------------------------------------------------------------------------------
| Command | Description       | Process                             | Effect            |
-----------------------------------------------------------------------------------------
| X       | Random element    | 4R -> [1 ... 4]X -> 2               | Random element    |
|         |                   |                                     |  of R             |
|         |                   |                                     |                   |
-----------------------------------------------------------------------------------------
| Ḋ       | Dequeue from list | 4R -> [1 ... 4]Ḋ -> [2, 3, 4]       | Range [2 ... n]   |
-----------------------------------------------------------------------------------------
| Ṗ       | Pop from list     | 4Ṗ -> [1 ... 4]Ṗ -> [1, 2, 3]       | Range [1 ... n-1] |
-----------------------------------------------------------------------------------------
| Ẇ       | Sublists of list  | 4Ẇ -> [1 ... 4]Ẇ                    | All sublists of R |
|         |                   | -> [[1], [2], [3], [4], [1, 2],     |                   |
|         |                   |     [2, 3], [3, 4], [1, 2, 3],      |                   |
|         |                   |     [2, 3, 4], [1, 2, 3, 4]]        |                   |
-----------------------------------------------------------------------------------------
| Ẋ       | Shuffle list      | 4Ẋ -> [1 ... 4]Ẋ -> [2, 1, 3, 4]    | Shuffles R        |
-----------------------------------------------------------------------------------------
| Œ!      | All permutations  | 3Œ! -> [1, 2, 3]Œ!                  | All permutations  |
|         | of a list         | -> [[1, 2, 3], [1, 3, 2],           | of R              |
|         |                   |     [2, 1, 3], [2, 3, 1],           |                   |
|         |                   |     [3, 1, 2], [3, 2, 1]]           |                   |
-----------------------------------------------------------------------------------------
| ŒḄ      | Non-vectorized    | 4ŒḄ -> [1 ... 4]ŒḄ                  | Bounces R         |
|         | bounce,           | -> [1, 2, 3, 4, 3, 2, 1]            |                   |
|         | z[:-1] + z[::-1]  |                                     |                   |
-----------------------------------------------------------------------------------------
| Œc      | Unordered pairs   | 4Œc -> [1 ... 4]Œc                  | Unordered pairs   |
|         | of a list         | -> [[1, 2], [1, 3], [1, 4], [2, 3], | of R              |
|         |                   |     [2, 4], [3, 4]]                 |                   |
-----------------------------------------------------------------------------------------
| Œċ      | Unordered pairs   | 4Œċ -> [1 ... 4]Œċ                  | Unordered pairs   |
|         | with replacement  | -> [[1, 1], [1, 2], [1, 3], [1, 4], | with replacement  |
|         | of a list         |     [2, 2], [2, 3], [2, 4], [3, 3], | of R              |
|         |                   |     [3, 4], [4, 4]]                 |                   |
-----------------------------------------------------------------------------------------
| ŒP      | Powerset of       | 3ŒP -> [1 ... 3]                    | Powerset of R     |
|         | a list            | -> ['', [1], [2], [3], [1, 2],      |                   |
|         |                   |     [1, 3], [2, 3], [1, 2, 3]]      |                   |
-----------------------------------------------------------------------------------------
| Œp      | Cartesian         | 4,2Œp -> [[1 ... 4], [1 ... 2]]Œp   | Cartesian product |
|         | product of z's    | -> [[1, 1], [1, 2], [2, 1], [2, 2], | of [1 ... z[i]]   |
|         | items             |     [3, 1], [3, 2], [4, 1], [4, 2]] | for i in z        |
-----------------------------------------------------------------------------------------

That's not entirely accurate. Yes, dequeue and Cartesian product do this, but sum wraps instead of creating a range, sort and reverse convert to base 10 first.

It's sometimes worthwhile to read from standard input when there are exactly two inputs
Jelly is optimized for taking input from command-line arguments. However, it's also optimized for writing monads rather than dyads; with dyads there are so many possible meanings for each builtin that you often need to spend characters to disambiguate, whereas with monads there are typically many ways to say the same thing.
As such, if you use one of two inputs only once, and the problem is such that it can't easily be implicitly read from ⁴ (i.e. you either need to make the ⁴ explicit, or else spend a character on }, @, or the like), consider reading it from standard input with Ɠ rather than placing it on the command line; that lets you precisely place the input right where you need it via the placement of your Ɠ, whilst ensuring that every other implicit input will be taken from your other input. That costs a byte and saves a byte, and depending on the problem, may well save a second byte by giving you more scope to reorder the code.

Ƒ combines very well with vectorising commands
For example: Ṡ returns the sign of an integer. If given an array, it applies Ṡ to each element and returns the corresponding array:
-3Ṡ = -1
1,2,-2,5,0Ṡ = 1,1,-1,1,0

Under Ṡ, only 1, 0 and -1 are unchanged. Therefore, ṠƑ returns true if its argument is one of 1, 0 or -1.
However, Ƒ doesn't vectorise over lists. This means that given a list and an atom that vectorises, it acts something similar to <atom>Ƒ€Ạ, which saves at least 2 bytes and potentially more if using filters and other quicks (<atom>Ƒ€Ạ$Ƈ vs <atom>ƑƇ). As an example, compare:
-,1,0,1,- ṠƑ
-,2,0,1,- ṠƑ

Try it online!

This works best with the following atoms. All of these vectorise with depth 0 unless stated otherwise, meaning they vectorise to all levels of nested arrays:

Atom
What does <atom>Ƒ test?

<nilad>
All equal nilad

A
All are non-negative

H, N, Ḥ, Ẓ  ÷, %, :
All zeros  ÷%: only work if the right argument doesn't lead to a division by zero

O
All numbers (i.e. no strings)

U
All subarrays are palindromes.  Note that due to the behaviour of ŒḂ on integers, this is different to ŒḂ€Ạ for flat arrays  See below for a breakdown of the differences and more details on UƑ

², Ḃ
All elements are 1 or 0

Ị, İ, Æ²
Only contains 1.  Can usually be replaced by Ȧ, but not always

Ọ
All strings (i.e. no numbers)

Ċ, Ḟ
All integers

Ṡ
All elements are -1, 0 or 1

×
All elements are zero  Or, the right argument is 1

+, _, ^
Is the right argument 0?

a, &
Are all elements 0 or equal to the right argument?

o
If the right argument is not zero, is the left argument all non-zero?  If the right argument is zero, return 1

|
If the right argument is zero, is the left argument all integers?  If the right argument is non-zero, are all elements equal to the right argument?

«
Are all elements less than or equal to the right argument?

»
Are all elements greater than or equal to the right argument?

For |^&, the arguments must only involve integers
UƑ
Due to U vectorising at depth 0 and ŒḂ not vectorising, UƑ, ŒḂ and ŒḂ€Ạ have very different behaviours in some cases (note that ŒḂ also checks if integers are palindromic by checking their digits):

If the argument is a flat list of integers/strings:

ŒḂ returns true if the list is palindromic
ŒḂ€Ạ returns true if all elements of the list are palindromic
UƑ  returns true if the list is palindromic

If the argument is a list containing integers and single nested lists (e.g. [[0, 1], 2, 3, [4, 5, 6]]):

ŒḂ returns true if the list is palindromic, ignoring if elements themselves are palindromic
ŒḂ€Ạ returns true if each element in the list is palindromic, ignoring whether the list as a whole is palindromic.
UƑ will always return false

If the argument is a list containing single nested lists (e.g. [[1, 2], [3, 4], [5]]):

ŒḂ returns true if the list is palindromic, ignoring if elements themselves are palindromic
ŒḂ€Ạ returns true if each element in the list is palindromic, ignoring whether the list as a whole is palindromic.
UƑ acts the same as ŒḂ€Ạ

If the argument is a list with multiple levels of nesting (e.g. [2, [2, 2], [2, [2, 2]]]):

ŒḂ returns true if the list is palindromic, ignoring if elements themselves are palindromic
ŒḂ€Ạ returns true if each first order element in the list is palindromic, ignoring whether the list as a whole is palindromic. This does not check the nested elements if they are palindromes, it just iterates through the first level elements and checks them
UƑ checks each subarray at all depths and returns true iff all these subarrays are palindromes. As UƑ returns false for integers, if the list contains any subarrays containing both integers and lists, it'll return false.

As an example, compare the behaviour of each will the following arguments:

Argument
ŒḂ
ŒḂ€Ạ
UƑ

[[2], [2, 2], [[2], [2, 2]]]
0
0
1

[2, [2, 2], [[2, 2], [2, 2]]]
0
1
0

[[2, [2, 2]], [2, [2, 2]]]
1
0
0

[[[2], [2, 2]], [[2], [2, 2]]]
1
0
1

Some additional helpful uses of Ƒ:

ṄƑ, ȮƑ and ṘƑ all print their argument and replace it with 1 if you need to output the argument and start a new chain with 1 as the argument. Saves bytes if the chain prevents using 1 as an unparseable nilad
FƑ and ẎƑ both test if their argument is a flat list
fƑ returns true iff the left argument consists entirely of the right argument.
ḟƑ returns true iff the left argument does not contain the right argument
ṁƑ tests if the left argument has the same "shape" as the right argument (i.e. length and depth of each element)
tƑ tests if the left argument begins or ends with the right argument (returning 1 if it does not)
ÆṣƑ tests if its argument is perfect, or, if a list, is all perfect numbers

Monads don't have to be monads
Not very frequently applicable, but in some cases where a series of monads (or dyad-nilad/nilad/dyad pairs, i.e. would be an LCC if there was a leading constant) grouped with $ƊƲ is to the right of a dyad in a monadic chain, but the (2,1) pattern is not desired, the grouping quick can be replaced with ¥ɗʋ without affecting its behavior at no cost. This pretty much only comes up if there's another quick applied to the group which inherits its operand's adicity, like Ƈ, and there's no monad to the right of that.

Optimal Integer / List Compression
An integer compressor exists for a single large integer already; however, there are many ways of representing integers and lists - basic literals, exponential literals, codepage index lists, long compressed numbers, and two-byte short compressed numbers. These are all mentioned in this thread, but this is a unified compression tool for all of them.
This is available of my site here (affiliation disclosure: I made this site. I don't get any money from it. It's just a project entirely for fun). In case my site ceases to exist (and also because this answer should be self-contained), you can use the following code snippet to compress any valid value (where a valid value is an integer or a list of valid values).
Note that this only compresses into literals. There are often shorter ways to represent certain numbers or lists using constants, base decompression, grade up / group indices, etc, but that is beyond what I have implemented for this, and this will always return a single literal representing the inputted value.

let codepage  = "¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !\"#$%&'()*+,-./0123456789:;<=>?";
    codepage += "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~¶";
    codepage += "°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂ";
    codepage += "ĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭ§Äẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«»‘’“”";

function go() {
  var value = document.getElementById("value").value;
  console.clear();
  if (value.match(/^\s*$/)) {
    console.log();
  } else if (value.match(/^[\[\]\d\s,-]*$/)) {
    try {
      value = eval("[" + value.replace(/\d+/g, x => x + "n") + "]");
    } catch {
      console.log("not a valid value");
      return;
    }
    if (value !== undefined) {
      if (value.length == 1) value = value[0];
      console.log(compress(value));
    }
  }
}

function compress(value, surround_list = false) {
  var converted = "";
  for (var f of [trivial, exponential, cp_index_list, compressed_integer, short_compressed]) {
    var c = f(value);
    if (c && (converted == "" || c.length < converted.length)) {
      converted = c;
    }
  }
  if (Array.isArray(value)) {
    var list_form = value.map(function(sub) {
      return compress(sub, true);
    }).join(",");
    if (surround_list || value.length == 1) {
      list_form = "[" + list_form + "]";
    }
    if (list_form && (converted == "" || list_form.length < converted.length)) {
      converted = list_form;
    }
  }
  return converted;
}

function trivial(number) {
  if (Array.isArray(number)) return;
  if (number == -1n) {
    return "-";
  } else {
    return number.toString();
  }
}

function exponential(number) {
  if (Array.isArray(number)) return;
  var exp = 0n;
  while (number % 10n == 0n) {
    exp++;
    number /= 10n;
  }
  return (number == 1 ? "" : number == -1 ? "-" : number.toString()) + "ȷ" + (exp == 3 ? "" : exp.toString());
}

function cp_index_list(numbers) {
  if (!Array.isArray(numbers)) return;
  if (numbers.every(function(x) {
    return !Array.isArray(x) && 0n <= x && x < 250n;
  })) {
    return "“" + numbers.map(function(x) {
      return codepage[x];
    }).join("") + "‘";
  } else if (numbers.every(function(x) {
    return Array.isArray(x) && x.every(function(x) {
      return !Array.isArray(x) && 0n <= x && x < 250n;
    });
  })) {
    var k = numbers.map(function(x) {
      return "“" + x.map(function(x) {
        return codepage[x];
      }).join("");
    }).join("") + "‘";
    if (numbers.length == 1) {
      return "[" + k + "]";
    } else {
      return k;
    }
  }
}

function compressed_integer(number) {
  if (Array.isArray(number) && number.every(function(x) {
    return !Array.isArray(x) && x >= 0n;
  })) {
    k = number.map(function(e) {
      var string = compressed_integer(e);
      return string.substring(0, string.length - 1);
    }).join("") + "’";
    if (number.length == 1) {
      return "[" + k + "]";
    } else {
      return k;
    }
  } else if (!Array.isArray(number) && number >= 0n) {
    var builder = "’";
    while (number) {
      var digit = number % 250n;
      if (digit == 0n) digit = 250n;
      number -= digit;
      number /= 250n;
      builder = codepage[digit - 1n] + builder;
    }
    return "“" + builder;
  }
}

function short_compressed(number) {
  if (Array.isArray(number)) return;
  if (number < -31349n || (number > -100n && number < 1001n) || number > 32250n) return;

  if (number < 0) number += 62850n;
  else            number -= 750n;

  var last = number % 250n;
  if (last == 0n) last = 250n;
  number -= last;
  number /= 250n;

  return "⁽" + codepage[number - 1n] + codepage[last - 1n];
}
input {
  padding: 5px;
  font-family: monospace;
  width: 100%;
}
<input id="value" type="text" placeholder="Enter a valid integer/list here" />
<br /><br />
<button onclick="go()">Compress!</button>

Most quick-link monads get a free {
Quicks that expect dyads typically error when run on monads, because most monads have their underlying call as a lambda accepting only one argument. However, most quicks that emit monads--whether conditionally or unconditionally--implement the emitted monad's call as a lambda accepting up to two arguments, with the only exceptions being Ɲɼ`⁺.
This is completely useless unless you're already severely abusing one of the handful of quicks that strictly require a dyad, but it can come up. I could also see this coming up with \ in some circumstance, most likely in conjunction with a simple grouping quick.

source: Stack Exchange

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

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

sort: votes


text:
Check work periods
Introduction
Here in Germany the ruling on work times is very strict. If you work 6 or more hours a day, you have to take at least a 30 minute break. If you work 9 or more  hours, you need to take a 45 minute break. If you work less than 6 hours, you don't have to take any breaks.
Of course you can split those breaks, but each part has to be at least 15 minutes long to be counted.
The  Challenge
In this challenge you will get a list of work periods and you have to check if enough breaks were taken, using the following rules:
Let w be the work time in hours:
w < 6         -> No breaks needed
6 <= w < 9    -> 30 minute break needed
w >= 9        -> 45 minute break needed

Additionally, each break has to be at least 15 minutes long. Also you can always take more breaks than needed. Those are all "at least" values.
Input
Your input will be a list of work periods. The exact format is up to you, but it has to contain only time values as hours and minutes.
Example:
Format here is a list of tuples while each tuple represents a working period. The first element in a tuple will be the start time, the second one will be the end time.
[("07:00","12:00"),("12:30","15:30"),("15:45","17:15")]

This results in a total work time of 9.5 hours and a total break time of 45 minutes.
Note that those working periods don't have to be separated by breaks. There can also be working periods which just follow each other (example see test cases).
Also note that breaks don't count into the working time. Those are two separate values.
You may assume that the working periods are ordered.
Output
Given this input, output a truthy value if enough breaks were taken and a falsy value if not.
Rules

Specify the input format you are using in your submission.
You don't have to handle empty input. There will always be at least one working period.
The working periods will only span one day, so you don't have to handle work over midnight.
Date-/Time-/Whatever- Builtins allowed, as long as it comes with your language.
Function or full program allowed.
Default rules for input/output.
Standard loopholes apply.
This is code-golf, so lowest byte-count wins. Tie-breaker is earlier submission.

Test cases
Same input format as in the example above.

[("07:00","12:00"),("12:30","15:30"),("15:45","17:15")] -> TRUE  // 9:30h work, 45 minutes break -> OK
[("07:20","07:45"),("07:59","11:30"),("11:55","15:00")] -> FALSE // 7:01h work, 39 minutes break, but first break does not count because < 15 minutes
[("06:00","09:00"),("09:00","11:50")] -> TRUE   // Only 5:50h work, so no break needed
[("07:30","12:00"),("12:30","16:00")] -> TRUE   // 8h work, 30 minutes break -> OK
[("08:00","12:30"),("13:05","17:45")] -> FALSE // 9:10h work, only 35 minutes break instead of the needed 45
[("08:00","14:00")] -> FALSE  // 6h work, no breaks, but 30 minutes needed

Happy Coding!

Pyth, 56 52 bytes
La.*bgsm*ydgyd15cPt_Jmid60Q2@[0030 45)hS,/syRcJ2C\´3

Takes input in the form [[hh,mm], [hh,mm], ...] with no leading 0s
Explanation:
La.*bgsm*ydgyd15cPt_Jmid60Q2@[0030 45)hS,/syRcJ2C\´3

La.*b                                                - def y(b): return absdiff(*b)

                    Jmid60Q                          - Unpack the input to mins and assign to J
                    J                                - autoassign J = V
                     m    Q                          - [V for d in Q]
                      id60                           - conv_base(V, 60)

      sm*ydgyd15cPt_J      2                         - Get the total break
                   _J                                - reverse(J)
                 Pt                                  - ^[1:-1]
                c          2                         - chop(2, ^)
                                                     -
       m                                             - [V for d in ^]
            yd                                       - y(d)
           g  15                                     - >= 15
         yd                                          - y(d)
        *                                            - y(d) * (y(d)>=15)
                                                     -
      s                                              - sum(^)

                            @[0030 45)hS,/syRcJ2C\´3 - Get the break required
                                             cJ2     - chop(J, 2)
                                           yR        - map(y, ^)
                                          s          - sum(^)
                                                     - Now have the total time worked in mins
                                         /      C\´  - ^/ord("`")
                                                     - (^/180)
                                                     - Now have the time worked in 3 hour intervals
                                      hS,          3 - sorted([^, 3])[0]
                                                     - (min(^, 3))
                                                     - Now have hours worked in 3 hour intervals capped at 9 hours
                            @[0030 45)               - [0,0,30,45][^]
                                                     - Get the break required for that time

     g                                               - break >= break required

Try it here
Or try all the test cases here

Javascript, 108 106 bytes
m=>(k=t=0,m.map(l=>(a=l[0]*60+l[1],k+=t?a-b<15?0:a-b:0,b=l[2]*60+l[3],t+=b-a)),t/=60,t<6||k>44||t<9&&k>29)

Takes an array of arrays. Each inner array has the start hour and minute and end hour and minute respectively for each period.

f=m=>(                           // assign function to f
    k=t=0,                       // k break // t work
    m.map(l=>(                   // for each period
        a=l[0]*60+l[1],          // started time in minutes
        k+=t?a-b<15?0:a-b:0,     // if there was a break add it
        b=l[2]*60+l[3],          // ended time in minutes
        t+=b-a                   // sum worked time (the difference)
    )),                          //
    t/=60,                       // turn t from minutes to hours
    t<6||k>44||t<9&&k>29         // the main logic
)                                //

document.body.innerHTML = '<pre>' +
  f([[07,00,12,00],[12,30,15,30],[15,45,17,15]]) + '\n' +
  f([[07,20,07,45],[07,59,11,30],[11,55,15,00]]) + '\n' +
  f([[06,00,09,00],[09,00,11,50]]) + '\n' +
  f([[07,30,12,00],[12,30,16,00]]) + '\n' +
  f([[08,00,12,30],[13,05,17,45]]) + '\n' +
  f([[08,00,14,00]]) + '\n' +
'</pre>'

Python 3, 135
Saved 3 bytes thanks to DSM.
This is one of my mathier solutions in a while.
def f(l):
 h=r=e=0
 for(a,b)in l:a+=a%1*2/3;b+=b%1*2/3;h+=b-a;r-=(e-a)*(e and(a-e)>.24);e=b
 return(h<6)|(6<=h<9and.5<=r)|(h>9and.74<r)

Here're my test cases, it also shows how I expect the function to be called.
assert f([(07.00, 12.00), (12.30, 15.30), (15.45, 17.15)])
assert not f([(07.20, 07.45), (07.59, 11.30), (11.55, 15.00)])
assert f([(06.00, 09.00), (09.00, 11.50)])
assert f([(07.30, 12.00), (12.30, 16.00)])
assert not f([(08.00, 12.30), (13.05, 17.45)])
assert not f([(08.00, 14.00)])

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

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