text:
Reverse Fibonacci
Your task
You must write a program, to print a reverse Fibonacci series, given a number.
Input
A non-negative integer N.
Output
You must output all the Fibonacci numbers from Fk to F0, where k is the smallest non-negative integer such that Fk ≤ N ≤ Fk+1.
Example
IN: 5

OUT: 5 3 2 1 1 0

If input isn't a Fibonacci number, the series should begin from the closest Fibonacci number less than the input.
IN:  15

OUT: 13 8 5 3 2 1 1 0

If input is 1, the series should be.
IN:  1

OUT: 1 0

Scoring:
This is code-golf, lowest byte count wins.
Leaderboard

var QUESTION_ID=136123,OVERRIDE_USER=60869;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

So normal Fibonacci and then reversing the output?

Yeah, I mean to 0, thanks!

Closely related.

@AdmBorkBork isn't that the 'inverse Fibonacci function' and not 'return the fibonacci sequence, reversed'?

I'd say it's actually the reversed inverse Fibonacci function. (Sort of ...)

@AdmBorkBork I was about to ask that, but specifically - "You must output all the Fibonacci numbers from N to 0." implies we are never contracted to output both 1s

I've updated your question with a more formal definition. Feel free to rollback anything you'd dislike.

@Arnauld Thanks for the correction!

Sorry for the multiple edits. I think it's correct now.

@Arnauld you have changed the spec to invalidate multiple answers I believe. I'd suggest allowing ...1,0 or ...1,1,0 for any n>0, as that was what was implied by the original spec (see my comment above).

@JonathanAllan I've updated the spec to reflect the rule "If input is 1, the series should be 1 0" (which was prior to my edit). But I tend to agree with you: both 1,1,0 and 1,0 should probably be allowed.

@Arnauld apologies for my mistaken attribution!

Neim, 5 bytes
f₁>

Try it online!
Explanation
f            infinite list of fibonacci numbers
 ₁>          get input and increment it
            first b elements of a
            reverse the list

I feel like this could be golfed more. ₁> feels a bit inefficient...

It is output fibonacci numbers up to n, not output the first n numbers.

@Emigna of course, my mistake. will revise or delete in a few hours

Haskell, 52 bytes
p=0:scanl(+)1p
f 1=[1,0]
f n=reverse$takeWhile(<=n)p

Second line is necessary for the n = 1 edge-case. I wasn't able to get around it.

Python 2, 62 59 bytes
n,l,a,b=input(),[],0,1
while a<=n:l=[a]+l;a,b=b,a+b
print l

Try it online!

61 bytes

59 bytes for input()-print format

This gives [1, 1, 0] for input 1, the correct output is [1, 0].

64 bytes but I feel like this definitely isn't the best way to do this...  Note: this properly handles 1 -> [1, 0] and not [1, 1, 0].

62 bytes cause I was stupid and had extra parenthesis.

Jelly,  9  8 bytes
ḤḶÆḞṚ>Ðḟ

A monadic link taking a number and returning the list of numbers.
Try it online!
Note: I am assuming 1s are not both required, if they are the previous 9 byter works: +2ḶµÆḞṚfṖ
How?
ḤḶÆḞṚ>Ðḟ - Link: number, n
Ḥ        - double n (this is to cater for inputs less than 6)
 Ḷ       - lowered range of that -> [0,1,2,...,2*n-1]
  ÆḞ     - nth Fibonacci number for €ach -> [0,1,1,...,fib(2*n-1)]
    Ṛ    - reverse that
      Ðḟ - filter discard if:
     >   -   greater than n?

...the reason this only outputs [1,0] for an input of 1 is that the unfiltered list does not contain fib(2), the second 1.
The 9 byter works by adding two, +2, to form the lowered range [0,1,2,...,n,(n+1)] rather than doubling and then filter keeping, f, any results which are in a popped, Ṗ, version of that same list, [0,1,2,...,n] (the value accessed by making a monadic chain, µ).

Mathematica, 52 41 bytes
{1,0}//.{a_,b_,c___}/;a+b<#:>{a+b,a,b,c}&

Fibonacci@Range[Floor[Log[GoldenRatio,1+√5#]],0,-1]&

Mathematica, 46 bytes
Reverse@Select[Array[Fibonacci,t=1+#,0],#<t&]&

Try it online!
thanx to @JungHwan Min for -16 bytes

Dyalog APL, 28 bytes
{x/⍨⍵≥x←⌽{1∧+∘÷/0,⍵/1}¨⍳2×⍵}

Requires ⎕IO←0.
Try it online!
How?
{1∧+∘÷/0,⍵/1} - apply fibonacci
    ¨⍳2×⍵ - to the range 0 .. 2n
x←⌽ - reverse and assign to x
x/⍨ - filter x with
    ⍵≥x - the function x <= n

Python 2, 58 bytes
Note: invalidated by recent specification change (1 -> (1, 1, 0))
n=input()
r=1,0
while r[0]<=n:r=(r[0]+r[1],)+r
print r[1:]

A full program accepting from stdin and printing (a tuple representation of) the numbers in the reversed order.
Try it online! or see a test suite

05AB1E, 9 bytes
ÎÅF)˜RIi¦

Try it online!
If [1, 1, 0] is valid output for 1 this would be ÎÅF)˜R at 6 bytes

Perl 6, 40 bytes
{[R,] 0,1,*+*...^{2>$_??$^a==1!!$^b>$_}}

Test it
Explanation:

{…} create a bare block lambda with implicit parameter $_
[R,] LIST is a Left fold using the reverse meta-op R combined with the comma op ,.
(shorter than reverse)
0, 1, *+* ...^ Callable produces a Fibonacci sequence that stops on the value before Callable returns a True value.

The remaining code is a bit complicated as it has to return True if the original input is 1 and the second to latest value is 1. This is so that the full lambda returns (1,0) instead of (1,1,0).
{ # bare block lambda with two placeholder params ｢$a｣ and ｢$b｣

    2 > $_    # is the original input smaller than 2

  ??          # if it is
    $^a == 1  # check if the second to latest value is 1

  !!          # otherwise
    $^b > $_  # check if the latest value is bigger than the original input
}

If the code was allowed to return (1,1,0) when given the value 1, it can be dramatically shorter at 22 bytes:
{[R,] 0,1,*+*...^*>$_}

Test it
In this case * > $_ creates a WhateverCode lambda that in this use-case will return True if the generated value is greater than the original input.
Everything else is the same as above.

Husk, 20 18 17 13 bytes
Thanks a lot @Zgarb for telling me about İf which is a built-in for Fibonacci numbers, this saved me 4 bytes:
§↓=1ȯ↔`↑:0İf≤

Try it online!
Ungolfed/Explanation
               -- implicit input N
          İf   -- get all Fibonacci numbers,
        :0     -- prepend 0,
      `↑    ≤  -- take as as long as the number is ≤ N,
    ȯ↔         -- reverse and
§ =1           -- if input == 1:
 ↓             --   drop 1 element else no element

Old answer without built-in (17 bytes)
The old answer is quite similar to shooqie's Haskell answer:
§↓=1ȯ↔`↑ȯƒo:0G+1≤

Try it online!
Ungolfed/Explanation
A really short way to compute Fibonacci numbers in Haskell is to define a recursive function like this (also see the Haskell answer):
fibos = 0 : scanl (+) 1 fibos

Essentially that code computes the fixpoint of the function \f -> 0 : scanl (+) 1 f, so you can rewrite fibos in an anonymous way like this:
fix (\f -> 0 : scanl (+) 1 f)

Try it online!
This corresponds to the Husk code (ƒo:0G+1), here's the remaining code annotated:
                   -- implicit input N
        ȯƒo:0G+1   -- generate Fibonacci numbers (ȯ is to avoid brackets),
      `↑        ≤  -- take as as long as the number is ≤ N,
    ȯ↔             -- reverse and
§ =1               -- if input == 1:
 ↓                 --   drop 1 element else no element

You can use the built-in İf for the list of Fibonacci numbers (I realized that this is not yet documented anywhere).

The part ´o↓=3 doesn't work like you describe. It's interpreted as argdup (.) . dropWhile . (==) $ 3, which drops leading 3s twice. Try it.

This seems to work for 13 bytes.

No problem. In general, you should use Ṡab instead of ´oab when the intended meaning is \x -> a (b x) x. It's shorter and has fewer possible types.

C# (.NET Core), 70 bytes
n=>{var t="0";for(int a=0,b=1,c;b<=n;c=a,a=b,b+=c)t=b+" "+t;return t;}

Try it online!
Input is an integer into the Lambda. Output is a space-delimited string of the fibonacci sequence in reverse.

Outputs 1 1 0 for 1 it should be 1 0

I must have missed that in the specc. I would think that N=0 would give 1 0. There are other solutions here that output 1 1 0 as well for N=1.
Anyway, I will work on making it conform with the specc.

You did not misread the spec, it got changed. I have commented about it.

Javascript (ES6), 42 bytes
f=(n,a=0,b=1)=>b>n|a>=n?a:f(n,b,a+b)+" "+a

Alternative, if f(1) = 1 1 0
f=(n,a=0,b=1)=>b>n?a:f(n,b,a+b)+" "+a

Example code snippet:

f=(n,a=0,b=1)=>b>n|a>=n?a:f(n,b,a+b)+" "+a

console.log(f(5))
console.log(f(15))
console.log(f(1))

Röda, 58 bytes
{|k|a=0;b=1{{[a];b=a+b;a=b-a}while[a<k,b<=k];[a]}|reverse}

Try it online!


text:
A-Z in 10's, you see?
As a follow up to my previous challenge Count to 20 with Words!, we will once again be using the word list from that challenge to perform another task. This time, you will be exclusively using:
https://github.com/Magic Octopus Urn/wordListsByLength/blob/master/10.txt
To choose 26 different words, each starting with a unique letter, and output them in ascending order from A to Z. Here's a valid example:
aardwolves
babbitting
caravaning
debilitate
evaporator
fantasized
geographer
hawfinches
imbecility
juvenility
kalanchoes
lamaseries
malodorous
nudibranch
oligophagy
pantywaist
quarreling
russetting
scantiness
teetotaler
undercount
voodooisms
wentletrap
xenophobic
yeomanries
zwitterion

This is an aardwolf, this is a hawfinch, this is a kalanchoe, this is a nudibranch and a wentletrap.

Rules

No reading directly from the repository, or any other loopholes.
You may select any 26 of the words provided in the link.

You choose words and these are the words your program should output every time.

One word beginning with each of the following letters must be selected:

[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]

This is code-golf, lowest byte-count wins.

Any other suggestions for spin-offs using the word lists?
Also, feel free to steal my word-lists and make challenges.

hey, just a small nitpick, the "previous challenge link" links to an answer, not to the challenge itself

Is the output required to be separated with newlines, or can the output be an array/separated with another delimiter?

I'm disappointed that a nudibranch isn't a bank in a nudist colony.

The rules include 'q' but the example does not.

Aardwolves are freaking adorable.

Bubblegum, 100 99 bytes
00000000: 45ce 4502 0420 0800 c0bb bfb4 3bc1 adcf  E.E.. ......;...
00000010: 6f23 b7a1 910b 63b3 0016 84da 40d4 fd41  o#....c.....@..A
00000020: 344c 2b81 e824 e09f 9e19 e4e9 8d3a 1353  4L+..$.......:.S
00000030: 3f7c c3fc 59b8 b732 5b07 62e7 c383 4fcc  ?|..Y..2[.b...O.
00000040: 4d5f 88c5 bd60 6f44 8c8d b87d 215e 78c3  M_...`oD...}!^x.
00000050: 359e ec4d 360c bd4a 94e2 6e25 e06f ef43  5..M6..J..n%.o.C
00000060: d286 17                                  ...

Try it online!
Output:
artinesses
businesses
cozinesses
dozinesses
easinesses
fastnesses
gastnesses
hazinesses
ickinesses
jokinesses
kindnesses
lazinesses
mazinesses
nosinesses
oozinesses
pastnesses
queasiness
rosinesses
sexinesses
tininesses
uglinesses
vastnesses
wilinesses
xanthomata
yeastiness
zaninesses

The words were again selected with simulated annealing:
from __future__ import print_function
import math
import random
import zopfli.zlib

wordlists = [[] for n in range(26)]
for word in open('wordListsByLength/10.txt', 'rb').read().splitlines():
    wordlists[ord(word[:1]) - ord('a')].append(word)

words = [random.choice(wordlist) for wordlist in wordlists]

temperature = 1.
score = 9999
best = score

while True:
    old_score = score
    n = random.randrange(len(wordlists))
    old_word = words[n]
    words[n] = random.choice(wordlists[n])
    score = len(zopfli.zlib.compress(b'\n'.join(words)) - 6
    if score > old_score and random.random() >= math.exp((old_score - score) / temperature):
        words[n] = old_word
        score = old_score
    else:
        temperature *= .9999
        if score < best:
            best = score
            print(best, repr(b'\n'.join(words)))

uglinesses is a possibility for the letter U that you missed, but this doesn't help much, since you still have Q, X, and Y to deal with. Nothing comes to mind for those.

@CodyGray The program chose all the words automatically from the entire dictionary, so no missing was involved, but I think it likes uneasiness for compressing well with easinesses and queasiness. It’s very consistent about those choices.

JavaScript (ES6), 168 bytes
For each starting letter, outputs either the first word ending in -inesses or the first available word.
_=>`ash0bus0coz0doz0eer0foz0gor0hom0ink0jok0kaiserdoms
log0mir0nos0ooz0pun0quackeries
ros0siz0tin0ugl0vacantness
wir0xanthomata
yardmaster
zan0`.split`0`.join`inesses
`

Demo

let f =

_=>`ash0bus0coz0doz0eer0foz0gor0hom0ink0jok0kaiserdoms
log0mir0nos0ooz0pun0quackeries
ros0siz0tin0ugl0vacantness
wir0xanthomata
yardmaster
zan0`.split`0`.join`inesses
`

o.innerHTML = f()

Jelly, 69 bytes
This is the naive approach it may be improvable by some clever ticks
“6)ọʋtL⁺%ḍʠ9ƲȮṆ'ṫZpɲṇḃb7ṗ³ðʠ©q€©[ẠṾṠɠ+ȯ!?^_iṘ©ð⁴ạ'8œÐṣTP³ḃXŻDƭƇM⁽H>Ỵ»

Try it online!
(Assumes that "Valid separators are ASCII-printable non-alphabetical characters (even numbers, don't care)" holds from the previous challenge)

Jelly, 49 bytes
“J9,⁹FṾ»ŒVŒlµL=⁵µÐf
¢Ḣ€OIT+“¢&ĠUṗɓṃ€~ƙṂ’D¤;@0‘ị¢Y

Try it online! (Takes about 22 seconds on TIO)
Outputs:
aardwolves
babbitting
cabalettas
daftnesses
earlywoods
fabricants
gadgetries
habiliment
iatrogenic
jaborandis
kaiserdoms
labialized
macadamize
naboberies
oafishness
pacemaking
quackeries
rabbinical
sabadillas
tabernacle
ubiquinone
vacantness
wadsetting
xanthomata
yardmaster
zabaglione

How it Works
“J9,⁹FṾ»ŒVŒlµL=⁵µÐf           - all length 10 Jelly dictionary words
“J9,⁹FṾ»                        - literal string "dictionary.long"
        ŒV                      - Python eval: get list of long words
          Œl                    - set all to lowercase
            µ   µÐf             - filter keep only those which meet:
             L                  - length
              =                 - equal to
               ⁵                - 10

¢Ḣ€OIT+“¢&ĠUṗɓṃ€~ƙṂ’D¤;@0‘ị¢Y - main link
¢                               - length 10 Jelly dictionary words from helper
 Ḣ€                             - first letter of each.
   O                            - ord: character values
    I                           - difference between consecutive elements
     T                          - indices of nonzero elements
                            (gets indices of first word starting with each letter)
      +                         - add
       “¢&ĠUṗɓṃ€~ƙṂ’D¤          - the list [2,0,5,9,1,3,3,1,1,6,1,2,0,0,0,0,2,1,1,1,0,3,1,8,0]
                      ;@0       - append 0 to beginning (golfable?)
                         ‘      - increment each element
                          ị¢    - index into the above length 10 words
                            Y   - join by newlines

Japt, 169 107 bytes
`a®
¾n
¯g
¸w
e
fox
g
z

jo
ê]
¦m
µt
nos
oil
po
qua×@i
c
 x
d
ugl
void
°r
xopb
yeÇ
z`·£`ê£`hX

Try it online!
I wrote a program that helps me optimize the compression. It sorts a list by its shoco compression size.

Wow, that optimization program is really cool. You forgot to replace inesses with 1 when calculating the compression length though ;) liminesses

Python 2, 256 231 220 bytes
i=97
for w in"uto ibli aco emo ntom utur laci olo deo ackfishes ymo exic alac omo cean alyn uaternion eno eri omo rban eno avelessly ero outhfully witterion".split():print chr(i)+(w+["graphy","ology"][w[3:]>''])[:9];i+=1

Saved 36 bytes thanks to Jonathan Allan, who did most of the hard work for this (I just found the words :P)
Try it online!

Some changes here using your approach to save 25 bytes. (move to Python 2 to save one more with print)

Actually even more here

'ACK! Fishses!' - First thing I saw when looking at this code heh.

Japt, 85 bytes
97
`...`£`...`hXiU°d}R

where the two pairs of backticks represent strings of seemingly random printable and unprintable characters. Try it online! Output:
achinesses
boninesses
cozinesses
dozinesses
easinesses
fozinesses
gorinesses
hazinesses
ickinesses
jokinesses
keennesses
lazinesses
mazinesses
nosinesses
oozinesses
pipinesses
quadrantes
riminesses
sizinesses
tininesses
uglinesses
vainnesses
warinesses
xylotomies
yeomanries
zaninesses

Explanation
The basic technique is:
97             Set U to 97
`ch
on
...`£  }R      Map each line X in this multiline string to:
U°d              Take U.toCharCode() and increment U.  ["a", "b", "c", ...]
Xi               Prepend this to X.  ["ach", "bon", "c", ...]
`cozinesses`h    Overwrite this onto the beginning of "cozinesses".
                 ["achinesses", "boninesses", "cozinesses", ...]
    £  }R      Rejoin with newlines and implicitly output.

I found cozinesses by starting with nesses as some other answers have used and repeatedly finding the previous letter that appeared the among the most of the 26 letters. Since greedy techniques are not often optimal, I later wrote a script to find the real optimal word:
alphabet="abcdefghijklmnopqrstuvwxyz".split``;
wordlist=alphabet.map(x=>[]);
document.body.innerText.split`\n`.slice(0,-1).map(x=>wordlist[x.charCodeAt()-97].push(x));
f=(q="",n=7,s=0,words=wordlist,z=n&&alphabet.map(x=>[x+q,words.map(y=>[y=y.filter(z=>z[n]==x),t+=0 in y][0],t=0),t]))=>n?z.filter(x=>x[2]>=Math.max(1,...z.map(x=>(x[2]-2)*2/3))).map(x=>f(x[0],n-1,s+26-x[2],x[1])).sort((a,b)=>a[1]-b[1])[0]:[q,s];

console.time("find optimal word");
console.log(f());
console.timeEnd("find optimal word");

(I don't care that it's incredibly ugly. This is how PPCG has taught me to code :P Don't worry, I don't do this in production.)
Anyway, when run in the browser console on the 10-letter word list, this outputs
[ "ozinesses", 57 ]

The 57 being the number of letters that would have to appear in the multiline string. It also took about 17 seconds on my computer, so be patient when you run it.
By replacing the f= line with
f=(q="",n=9,s=0,words=wordlist,z=n&&alphabet.map(x=>[x+q,words.map(y=>[y=y.filter(z=>z[n]==x),t+=0 in y][0],t=0),t]))=>n?[for(x of z.filter(x=>x[2]>=Math.max(1,...z.map(x=>(x[2]-2)*2/3))))for(y of f(x[0],n-1,s+26-x[2],x[1]))y].sort((a,b)=>a[1]-b[1]).filter((x,i,a)=>x[1]<=a[0][1]+20):[[q,s]];

you can get all suffixes within 20 chars of the optimal one. (Change the 20 at the end to something else to adjust this. Note: this function probably only works in Firefox.) You can find a list of all suffixes under 100 here.
Anyway, from there on it's just a task of finding the word for each letter of the alphabet that has the longest suffix in common with ozinesses. I wrote a Japt script to do this, as well as compress the necessary prefixes for me and tell me how long the resulting program will be. (You'll have to manually paste the word list between the quotation marks though.)
This explanation was probably somewhat confusing, so please feel free to ask any questions you may have.

Bubblegum, 110 106 bytes
Hexdump:
0000000: 45cc 4116 8240 0c83 e1bd b72c 50a1 0ed3  E.A..@.....,P...
0000010: 2015 454e 2fcf 4727 bb6f 91fc 1293 b946   .EN/.G'.o.....F
0000020: 68dc 3aec c91e 4772 2055 2279 e776 94aa  h.:...Gr U"y.v..
0000030: 1727 695b f392 7ca0 b1b8 f445 573b 39f3  .'i[..|....EW;9.
0000040: 5679 7344 1236 2717 169e 5b2b acdc 0663  VysD.6'...[+...c
0000050: 2f72 1b5b e10d 1b2e 7ed8 ddd5 b14c e84e  /r.[....~....L.N
0000060: 7e15 55fc df3d c473 f003                 ~.U..=.s..

Try it online!
Prints:
ashinesses
boxinesses
cozinesses
dozinesses
easinesses
foxinesses
gamenesses
hazinesses
inkinesses
jokinesses
knackeries
lamenesses
mazinesses
nosinesses
oilinesses
pokinesses
quackeries
rosinesses
samenesses
tamenesses
uglinesses
voidnesses
wilinesses
xenophobes
yeomanries
zaninesses

Javascript (ES6), 163 bytes
_=>`ach
bon
c
d
eas
f
gam
ha
ick
jok
keen
la
ma
nos
o
pip
quackeri
rac
si
tid
ugl
vain
war
xenogami
yeomanri
zan`.replace(/.+/g,s=>s+"-ozinesses".substr(s.length))

f=
_=>`ach
bon
c
d
eas
f
gam
ha
ick
jok
keen
la
ma
nos
o
pip
quackeri
rac
si
tid
ugl
vain
war
xenogami
yeomanri
zan`.replace(/.+/g,s=>s+"-ozinesses".substr(s.length))
o.innerText = f()

Nice! This translates to 144 bytes in Retina.

Heh, I just noticed this is exteremely similar to the technique in my Japt answer--I've even proven this wordlist optimal for this technique. Can you save a byte by changing /.+/g to /.*/g, -ozinesses to cozinesses, and removing the lone c?

@ETHproductions that would add "cozinesses" to the end of each line, since /.*/g matches a group of 0 characters after each line.

Python 2,  168  166 bytes
i=97
for w in"ch on ag ew as ox am az ck ok azatsk ac at os il ip uacker ac ex id gl agilit ar enogam eomanr an".split():print"%c%si%ses"%(i,w,"ness"*(len(w)<3));i+=1

Try it online!
How?
Initialises i to 97 (the ordinal of the character a) then loops through a list formed by splitting a string at spaces forming and printing the words, incrementing i as it goes. Most of the entries, w, in the list are of length two, these are words that start with the alphabetic letter and end in inesses, i.e. of the form:
chr(i)+w+'inesses'.
The entries of length 6 are of the form:
chr(i)+w+'ies'
This means a formatting may be used to prepend the alphabetic letter and add an ending with the 'ness' inserted like 'i'+?+'es' when w is short like so:
"%c%si%ses"%(i,w,"ness"*(len(w)<3))
- %c converts i to a character; the two %s insert w and "ness"*(len(w)<3), where the latter is "ness" if w is short or "" if w is long.

Even nicer! This translates to 140 bytes in Retina.

SOGL V0.12, 66 bytes
"⅟μ█X§¡Ψ}|μ⁾k,²9γ↑č─[╝B4mh|c↑′ρ╤τnE╗Ζ±$ņ¦Pγ9¬oΘ′`║F→█#▲xpņRe└ωηηƨ‘

Try it Here!
A simple dictionary compession with the problem that no word that starts with X was in SOGLs dictionary, so I compensated with xenotropic - tropic was in the dictionary. And I needed to add the starting quote because otherwise the parser thought that [ started a loop :/

Charcoal, 84 bytes
ＵＯχ²⁶”m⌈⎚∧³δ¤↶””｜↖⧴=P“⪪šl¢‘υKBＳＡＤ ⁶⁸ςz↧\–～⎇Ｖ▷–ê"℅ ž⟲‹‹⮌0Bff5Ｙ⪪Ｅ？Þ¹@)⟦£δＴ⪪⌕↙]\ＲＺ_Ｑ‹″”

Try it online! Uses @HermanLauenstein's wordlist, but I saved one byte because I can miss out the f. For once, somewhat competitive even in in verbose mode, which is only 166 bytes. Try it online!
Oblong(c 26 "fozinesses")Print("ach\nbon\nc\nd\neas\n\ngam\nha\nick\njok\nkeen\nla\nma\nnos\no\npip\nquackeri\nrac\nsi\ntid\nugl\nvain\nwar\nxenogami\nyeomanri\nzan")

Why did you score this as 166 instead of 84?

@ConorO'Brien I just thought it was amusing that I was still tying with Python.

source: Stack Exchange

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

sort: votes


text:
Restricted mini challenges Cop's Thread

Robber's thread

Your task as cops is to select three things:

A programming language
An OEIS sequence
A byte set

You are then to secretly write a program in that language that computes the nth term sequence using only the bytes in the set.  You will reveal the three pieces of information so that robbers can try to figure out the program.
Answers will be scored by the number of bytes in the byte set with more score being good. Cracked answers have an automatic score of 0.  If your answer is uncracked after one week you may reveal the intended program and mark your answer as "safe".
Answers must be capable of calculating every term in the b-files of the sequence, but are not required to calculate any terms after.
Sequences can be either 1 or 0 indexed for both cops and robbers.
Here is a Python Script that checks if your code matches the given byte set.

Lower score is better? Or higher? So in essence we're trying to find a restricted character set that makes it difficult for someone else to make a program in the chosen language, after we've already worked out a solution?

Do we need to use all the bytes in our set? I would guess yes but it should probably be specified in the challenge.

@Shaggy generally no, you can includes others for red herrings, but robbers can use everything

Do we count newlines as a separate byte or as \n?

@StepHen does that mean that you can include bytes that aren't even part of your language to get a higher score?

@H.PWiz you'd have to ask WheatWizard about no-ops

Can robbers use the same byte twice or more?

@mrxcoder I would think so, else we are just finding anagrams.

@Mr.Xcoder You are then to secretly write a program in that language that computes the nth term sequence using only the bytes in the set. only the bytes in that set, so dupes are allowed

Do I understand right that the robber could (if characters allow) hardcode an enormous table of values corresponding to the b file? This could be hard for cops to avoid.

@xnor Yes that would be possible.  The problem is OEIS sequence do not have rigorous specifications, so we can only confirm via test battery.

What do you mean by "b-list"? Is that the list of terms shown on the page that has the "list", i.e. http://oeis.org/A000004/list ?

@Azulflame The b-files are files that are associated with each sequence the can be accessed by replacing the A with a b and appending a .txt.  For example https://oeis.org/b4.txt would access the b-files for that sequence.

Can the byteset contain non-printable-ASCII? (i.e. can I inflate my score by including 0x00-0x1f and 0x7f-0xff?)

@Doorknob Yes it can, the question is about chiefly about bytes and is agnostic to characters.

Is input of the number necessary, or can we just print all of the sequence?

Haskell, A209229, (cracked)
11 characters (including newline):
s<=[ ]
how!

Outputs True/False as an indicator function for powers of 2:
1 => True
2 => True
3 => False
4 => True
5 => False
6 => False
7 => False
8 => True
9 => False
...

Inputs are positive integers.

Does 0 give False?

@H.PWiz My code doesn't work for 0, your crack can do whatever you want for it.

Cracked! Very clever~

@Lynn Nicely done!

Python 2, A000045 (Cracked)
ml:= input(as,forge)

it contains a whitespace and a newline
Try it Online!
Intended solution

+1 I am surprised this doesn't use + at all

Congrats on 10k btw :)

Cracked

@Mr.Xcoder Don't know python that well, but would plus work?

@JarkoDubbeldam No, sum would

@Mr.Xcoder yep, saw that just now... Derp :)

Haskell, A000045 (cracked)
I made up my mind, I think I like t more than s.
So let's use these 30 bytes (including newline) instead:
abcdeFgh|jklmnopqrtTuvwxyz
=()

Please note that the general challenge description demands that

Answers must be capable of calculating every term in the b-files of the sequence [...].

In this case, the b-file goes up to the 2000th number, which is way beyond what can be computed using Int.

Cracked!

Cracked

Haskell, A034262, 43 bytes, cracked
 !"#%',.=?ABCDEFGHIJKLMNOPQRSTUVWXYZ[]_{|}~
Computes a(n) = n³ + n.

Can't get the b-file now. Is returning an Int good enough?

Cracked?

@ChristianSievers Yes, that's exactly my solution.

Octave, A000290, Cracked!
The sequence is the square numbers: 0, 1, 4, 9, 16, 25, 36, 49 ... (so that you don't have to check the link).
'()/@^_

Cracked!

That was indeed the intended solution :)

Haskell, A000045 (Cracked)
Everyone likes Fibonacci numbers, I like Haskell...
I have carefully selected 30 bytes for you: the lowercase letters except f, i and t, you get the uppercase letters F and T and the pipe symbol | instead, and the three symbols =(), and newline. Here they are again:
abcdeFgh|jklmnopqrsTuvwxyz
=()

Cracked

Haskell, A009056 (cracked)
Another simple one, now again with enough letters to make it look like ordinary Haskell and maybe for you to amaze me by finding a solution completely different from mine.
The sequence is Numbers >=3 and the charset consists of these 30 bytes:
{[abcdefghijklmnopqr uvwxyz]}.

The crack has some nice techniques. I was just thinking of this:

 head . flip drop [ floor pi .. ]

Cracked.

Seed, A005408 (Odd Numbers) - Safe
Here's a slightly more challenging one. You may use any characters valid in Seed:
[0-9 ]

You shouldn't be able to brute force this one in a week unless you have a monster of a computer. Good luck! It's crackable.
Hint

This is the Befunge-98 program used in my solution: 9&2*1-.@ (the 9 can be removed, but my solution just happens to have one)

Solution
8 [encoded data, 6011 characters]

How did you generate this?

@2EZ4RTZ Painfully, and with Python's source as a reference. It can probably be golfed a lot though.

Haskell, A000045 (cracked)
It's cracked, and I won't start a new version, but if you want to play more: it's possible without y, and it's possible to be efficient.

I apologize for leading you in wrong directions by giving a g.
Let's do the same without!
Here are the 29 remaining bytes (including newline):
abcdeFh|jklmnopqrtTuvwxyz
=()

Again, remember that Int won't be enough to compute the 2000th Fibonacci number which is needed because it is in the b-file.

Cracked

C (C99), A000005, 25 Bytes#, Cracked!
These are the bytes for a full problem, takes n as a command line argument and outputs answer to stdout.(Space is included in bytecount).
<=>,;!"()*%+acdfhimnoprt

ok I was wondering lol. as a command line argument?

Yes, I'll make that clearer

Cracked! this was fun :D

Unary, A002275, 1 Byte
Byte set:
0

I had to at least try it :3
(I don't think it will be particularly hard seeing as every command in the language is available)

Why not include all of the bytes to maximize your score?  You have scored the lowest amount possible, when it would make no difference to include all of the bytes.

I thought we were going for a low score (sorry, I'm new here).

Cracked

@muddyfish Is input as a character allowed for brainfuck?

@sonar235 In general we do allow input as character for brainfuck.  Although since values here exceed 255, I don't think an answer that uses them can be valid.

@muddyfish Good to know. Would certainly have simplified my solution lol

muddyfish's solution is still not valid though see my edited comment.

@WheatWizard Didn't catch that, thanks.

Cubix, A000027 (SAFE) 17 points
!&')-/0;@Oiru.NSQ

My solution:
!O!;i)!/u&!!r-)0'u;;!@

watch it online here
I originally did this without .NSQ but I figured I could add them safely.
Explanation:
This sequence is just "The Positive Integers". However, Cubix has three input commands, i, which reads in a single char (pushing -1 if input is empty), A, which reads in the rest of the input as chars (pushing a -1 to the bettom of the stack), and I, which reads the next number off the input (pushing 0 if there isn't a match). So naturally, I only provided i which reads in digits as their ascii value. uh-oh. Additionally, -1 is the usual marker for end of input, in conjunction with ? so I got rid of ?, forcing me to use ! (skip next instruction if TOS is not zero) for control flow. Finally, I thought I needed & to concatenate digits for printing with O (which outputs the top of stack as a number), but I realize now that that wasn't necessary either!
Another part of the challenge was originally to not have . the no-op character, but you can use pairs of ! instead if you're careful:
    ! O
    ! ;
i ) ! / u & ! !
r - ) 0 ' u ; ;
    ! @
    . .

i) : read input, increment.
!/ : if top of stack is zero (end of input), turn left
left: ;O.@ : pop top of stack, output as number, halt.
otherwise:
u'0: push char code of 0 to top of stack
)-r: increment, subtract, and rotate
;; : pop top of stack twice
u& : concatenate digits
!! : net zero effect, now we are at i) again.

Cubix has some noop characters right? Why don't you add those to increase your score?  Or is part of the challenge that there are no noops.

@WheatWizard I decided to be merciful and add . but it can be done without it.

Hexagony, A057077, 77 bytes
Periodic sequence 1, 1, -1, -1. As a list:
a(0) = 1
a(1) = 1
a(2) = -1
a(3) = -1
a(4) = 1
a(5) = 1
a(6) = -1
   ...

Character set (edited), which includes a newline and a space character:

!%&(),0123456789;?@ABCDEFGHIJKLMOPQRSTUVWXYZ^abcdefghijklmnopqrstuvwxyz[]#.

Try it online!

Any reason you modified the character set?

@Poke apparently the higher the byte count the better, so I just added a bunch of non-useful commands.

Perl 5, A000030 (Cracked)
Byte set:
imnprt7 $;()<>=~.

Try it online!

Cracked!

JavaScript (ES6), 17 bytes, A000290 (Cracked)
Again, this is the simple square sequence a(n) = n2.
Byte set:
$()=>CI`abelotv{}

Cracked!

Haskell, A000045 (cracked)
This is kindof (as announced) not a new version, but completely different. (Right?)
I still hope I can make you rediscover my nice little observation.
This time you are asked to implement the Fibonacci sequence using a charset of size 17, which (as far as I know) contains only one two unneeded chars:
eilnt=(,).[ ]_:0!

Note that there is no newline (but feel free to show a version which has them for readability) and remember that you have to be able to compute the 2000th Fibonacci number.

Cracked.

JavaScript (ES6), 13 10 bytes, A000045, Cracked
This should be easy.
This is the Fibonacci sequence: F(n) = F(n-1) + F(n-2) with F(0) = 0 and F(1) = 1.
Byte set:
$()-:<=>?[]_~

Edit:
It can be even done with the following 10 bytes:
$()-:=>?_~

Cracked!

This isn't [code-golf]: "Answers will be scored by the number of bytes in the byte set with score being good." More bytes are better.

@LarsW on the other hand, more bytes also makes it easier to crack :)

Snowman, 212 bytes, A000042
#$%&*01:;=?@CEFGHIJLMOQUVXYZbcdefghijlmnopqsuvxyz~

... plus space, 0x00-0x1f inclusive, and 0x7f-0xff inclusive.

Python3, A008615, Cracked
Bytemap (with newline):
n)ir=-
(u0*pt

Cracked

R, A105311, (Cracked)
Byte set:
'%(),:=acdegilnopstx

cracked!

Braingolf, A010701 Score: 9 [SAFE]
Byte set:
0x21, 0x24, 0x2F, 0x3A, 0x3F, 0x5B, 0x5D, 0x5F, 0x7C

Try it Online!
The code:
$_/[!?:]|[!?:]|

Try it online!
Explanation
$_/[!?:]|[!?:]|  Implicit input from commandline args
$_               Remove top of stack
  /              Niladic division, push 5
   [...]         While loop, decrements bottom of stack at start of loop
                 then decrements each time loop reaches end
                 Exits when bottom of stack is 0
    !?:.|        If conditional without popping, runs contained code if top of stack is 0
                 This is the sneaky trick here. The conditional skips the end of the loop
                 As a result, this whole block from [ to | effectively acts as a decrement.
         [!?:]|  We do this twice to lower the 5 we pushed down to 3
                 Implicit output of top of stack.

So, I was wondering why nobody had solved this yet, and I realised it relies on an undocumented feature of while loops. Whoops! Try experimenting around a little with while loops and conditionals, and you should find the answer fairly easily ;)

This is now safe.

cQuents, A000217, Cracked
Byteset:
$:=1;
\-

Note that this uses a feature that I haven't pushed the documentation for yet, so I'll push that tonight, if you wait until then. (Or you can slop through my source code... have fun). Documentation pushed. Would be a byte less if a recent bugfix was on TIO.
Intended solution:

 =1-1:--\1$
 ;$

Try It Online!

Cracked!

R, A000142, (Cracked)
Byte set:
-()*,`=cfinotu

Intended solution:

 f=function(n,c=n==n)'if'(n,f(n-(n==n),c*n),c*(n==n))

cracked!

Python 2, A000045 (Cracked)
l:= input(a,forge)[]

it contains a whitespace and a newline
Try it Online!
Intended solution

Cracked

PowerShell, A000012, 19 bytes, SAFE

$.0=[]acefilnorstv

Includes a newline and 18 other bytes. Good luck.
Try it online!

Intended Solution:
$a=$a[0]
$error[0].invocationinfo.offsetinline

Try it online!
This sets $a to be the value of an uninitialized variable $a indexed at [0]. Since that won't work, you get an error stating the following:
Cannot index into a null array.
At line:1 char:1
+ $a=$a[0]
+ ~~~~~~~~
    + CategoryInfo          : InvalidOperation: (:) [], RuntimeException
    + FullyQualifiedErrorId : NullArray

The second line then pulls the .InvocationInfo and .OffsetInLine (i.e., where the error occurred), which in this case is always 1, and hence the A000012 sequence.

cQuents, A000027, Cracked

 !"#%&'()*+,-./0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
That's right! You get all of ASCII! Wait... there's no $... what's $ again in cQuents? Oh, yeah, the index builtin. Well, tough luck :/
Intended Solution:

 #|A:A

Try it online!

Cracked?

@Adnan yup that works, I guess I shouldn't have opened it up as much as I did :P I couldn't think of any different ways to do it, good job. Added intended solution.

R, A105311, (cracked)
'%(),:=acdeginpstx

Let's try this without the l or o.
Since this has been cracked, the intended solution:

 cat(diag(diag((a=scan()))%x%diag((a==a):a)),sep=''). diag is an interesting function, that can be used in three different ways. When presented with a single integer (diag(n)), it creates a NxN matrix with 1 on the diagonal. When presented with a vector (diag(1:n)), it creates an NxN matrix with the vector on the diagonal. When presented with a matrix (diag(diag(n))), it returns the diagonal as a vector. %x% computed the Kronecker product of two matrices, where each element in matrix 1 is multiplied with each element in matrix 2 separately. Doing this with a length n identity matrix and a 1:n diagonal matrix, creates a length n^2 diagonal matrix with 1:n repeated n times. diag extracts that again, and cat prints.

this'll be even more fun :)

does this include a newline?

@Giuseppe No newlines

@Giuseppe and I just double double checked, this byteset is correct

cracked!  -- I (incorrectly) used %o% before I realized that %x% existed. I guess I could have done 'i'=='i' for 1 but either way works, so.

@Giuseppe to be honest, I noticed the function and searched a sequence to match it :p

@Giuseppe Added intended solution and explanation :)

Befunge, A000142, 29 Bytes, (Cracked)
Byte Set: @.$_ ^*:\v>-1&

If you can't tell, that Byte set includes a space.
This should be moderately easy to solve.
Edit: Forgot the "A" before the OEIS

Cracked

R, A057077, (cracked)
1, 1, -1, -1, 1, 1, -1, -1, etc

Byte set:
()*/=2abcinopst

0-indexed.

Cracked.

C, A027868 (Cracked)
I don't expect this to last too long...
Byte set: int (){reu<5?-:/;}

cracked

CJam, A000042, cracked by Lynn
Byte set:
{})_%si

Cracked! Cute~

R, A000290, (cracked)
Byte set:
()%cfinotu

no c, but everything else for function? That's horrifying. I know how to do this except for reading in input...

@Giuseppe woops, the a shouldve been  a c. sorry.

This is what I get for doing this shit manually...

No worries; this is tough enough!

cracked

plus it's way easier to be a robber than a cop...

I'll try to come up with something for you in R

Ruby, A000004, 5 bytes, Cracked
Just messing around to start off. Should be easy for anyone familiar with Ruby. It's a low score, but whatever.
/np.$

Cracked, unintended exploit
Cracked (intended answer using n flag)

Cracked?

@Adnan Eh, I'll accept it. Should've required the n flag (which is the reason it's in the byte sequence, and would make $. equal 1)

Think I have your intended solution

Python 3, A007504 (Cracked)
This byteset, including newline:
bfuwo)nm1h[=(t+;0a
sig%pr, le:]

My code does not provide infinite output, but can compute the entire b-list.

Welcome to PPCG!

Cracked

Jonathan, put it in python 3 and I'll test it when I get to my pc.

Scrap that I used a . :(

I've fixed the crack.

...and migrated to Python 3.

CPython 3.6.2, A000002 (cracked)
I don't want anybody running out of single-character variables, so I'm giving you 70 pseudo-random characters courtesy of Latin-1.
·èõÉÀ]ýÜâô¾×l¡¿Ós¦Í½²uÊi´#¬©Åñ[);?ò
à¢ådêøóÎÐþÒÏ®,(Öß.=Õc_ö\§éºún$tÞb¨

This is evil. You can't make a for loop. You can't make a while loop. You can't even try to do anything, much less except. I have given a new line so that you can use more than one statement, but there aren't any spaces, tabs or even colons to let you use any sort of flow control. There are no numbers. There are no strings. There is nothing of any use.
You do have \ and #, though, so you can write clear code with soft breaks and comments.
That is, if you speak Jelly.

cracked with over 28kb of code

@ppperry Congratulations. It is possible to get much smaller than that, though.

I knew I was posting an unnecessarily long crack, but cracked is cracked, and it's only one day away from being safe.

@ppperry Fair point. Nobody else is probably going to attempt it, so there's no point saying that it's suboptimal.

@ppperry That's not supposed to be there... Oh well.

Python 2, A000142, cracked
Probably not too difficult, but since I really enjoyed solving these I thought I'll be a cop for once. Here's the byteset (first one is a space):
 ()*-:=abcdfghijklmoqruwyzABCDEFGHIJKLMNOPQRSTUVWXYZ

Intended solution
LyricLy's solution is much cleaner, but here's the one I had in mind:

 Basically it's the same but instead of using bool(r) for 1 I used (r-r)**(r-r): f = lambda r: (r==r-r or r==(r-r)**(r-r))*(r-r)**(r-r) or r*blam(r-(r-r)**(r-r))

Cracked.

JavaScript (ES6), A000035, cracked
A000035 is n mod 2, in case the site goes down or you're too lazy to check yourself. Charset:
023456789\`efu

Taking the "somehow still Turing-complete" route. I suppose I could've added 51 or so non-ASCII chars to improve my score, but that feels kind of like cheating.
Takes input through prompt and outputs through alert, and can be run in any modern browser.

Intended solution:
\u0046\u0075\u006e\u0063\u0074\u0069\u006f\u006e`\u0046\u0075\u006e\u0063\u0074\u0069\u006f\u006e\u0028\u0046\u0075\u006e\u0063\u0074\u0069\u006f\u006e\u0028\u0022\u0072\u0065\u0074\u0075\u0072\u006e\u0028\u0034\u0038\u0032\u002f\u0032\u0029\u002e\u0074\u006f\u0053\u0074\u0072\u0069\u006e\u0067\u0028\u0032\u0032\u0029\\u002\u0062\u0027\u0065\u0072\u0074\u0028\u0070\u0072\u006f\\u006\u0064\u0070\u0074\u0028\u0029\u0025\u0032\u0029\u0027\u0022\u0029\u0028\u0029\u0029\u0028\u0029```
which, when the escapes are removed, translates to
Function`Function(Function("return(482/2).toString(22)\u002b'ert(pro\u006dpt()%2)'")())()```
which simplifies again to
Function`Function(Function("return(482/2).toString(22)+'ert(prompt()%2)'")())()```
This works because JavaScript allows \uXXXX escapes in variable names (though not in arbitrary code, as Java does). The outer Function`code``` is necessary to run the code at all, since the entire thing needs to be escaped.
(If you're confused about how this works: JavaScript has something called tagged template literals, which for our purposes is just a function call on a string; it just uses f`string` instead of f("code"). So Function`code``` is about the same as Function("code")().)
Now, because of the lack of the hexadecimal chars 1abcd, we'll have to double-encode certain necessary characters such as the m in prompt(). So instead of \u006d, it becomes \\u006\u0064. But now we need to evaluate this as a string twice to make sure this gets fully decoded. (pro\u006dpt() would work just fine, but using \u002b as + would not.) This is what the second Function(code)() is for.
One further obstacle exists: there's no 1 in the charset, necessary to create an a from \u0061. So there's no way to generate an a by unescaping a string (I checked, the octal representation is \141). Instead, we can generate it with e.g. (20/2).toString(20). I went ahead and generated al in this manner because l would require double-escaping like m.
But the problem now is that the innermost Function call is now just generating a string. In order to actually execute it, we need to return it from the function and pass it to a third Function call. This we do, and finally our journey is complete.
*I am aware of using ${} within template literals, but those aren't in the charset, alright?

Cracked!

Cubically, A016742 (Cracked)
This sequence is even square numbers: 0, 4, 16, 36, 64, ...
Byte set:

Any letter except [UuDdLlRrFfBb]
The digits [6789]
Any symbol except [-^:@/]
Anything not mentioned in the ASCII character set, including whitespace.

Try It Online!

You don't need to include that last note; languages (and language versions) made after the challenge are perfectly valid as of a new consensus.

@MDXF I wanted to specify which version to use. It was created before loops, but after input. Future language changes may warrant changes to the answer.

I suggest not changing the answer after this has already been posted. People may be working on a crack.

@MDXF I know, I won't. I was just saying why I specified the version. I guess if anyone wants to crack it with future language versions, they're welcome to.

Cracked

Python 2, A006577, Cracked
Byte set:
+s-t,n u
r)i1(d>]f[:e&

Shouldn't be too hard, but still fun.
EDIT: Cracked by @BruceForte.  The crack looks just about identical to my crack, but here's mine for reference.
Try it Online

Did you mean to include a p, or was that intentionally left out?

@Azulflame p isn't needed since it seems that printing is not required as long as the value is somehow returned.  See here for a non-contested, and valid, crack.

Cracked.

Python 2, A001146, Cracked
Byte set:
print(2*u)

Cracked

Python 3, A000002, Cracked with the intended solution
These are the bytes of a full program, 0-indexed solution for the Kolakoski sequence: OEIS A000002.
pg*rn:e+%2a tu]
(=foi[)1l,

This contains a space, a newline, and all the other characters in the snippet above. Hopefully this won't be too easy to crack :)

Cracked!

Python 2, A000042, 11 Bytes (Cracked)
Byte set:
int(pru*1)'

Answer:

 print '1'*input()

Note: This is my first ever answer on PPCG, and I may have made a mistake...

Cracked? This doesn't work for the 0 term, but it seems that this was the intended program.

@notjagan also what I just got - Bobawob, does yours work for 0?

Could it be 1 indexed instead?

Yes, it was the intended program. Sorry, did I need to include the 0th term? Like I said, this is my first ever challenge.

@Bobawob just switch it to this sequence, which is the same just without a leading 0

Unreadable, A000027, 92 bytes, Cracked
Byte Set:
!"#%&'()*+,-./0123456789:;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Also add space and newline

Why not include all of the bytes for maximum score?  There is no loss to adding more bytes if they can't be used.

There are no other bytes in unreadable that I used. I don't even think that there are other bytes in the language... Could I add all of ASCII even if my language doesn't use some of the characters?

Since Unreadable is encoded in ASCII you can and probably should use all the characters in ASCII.

Cracked

It's not cracked yet! You are forgetting that the first value in A000027 in 1, not 0.

My answer is 1-indexed

Then it's cracked. You're right, I forgot about that...

I went ahead and added the 0-index version for you

LOLCODE, A000290, Cracked
Byte set:
.12ABDEFGHIKLMNOPRSTUVXY

The byte set also includes space and newline.
HAS FUNZ!

Are we allowed newlines? As far as the interpreter I'm using (your link), they are required to not get errors.

Yes, there are newlines... Sorry!

Also 1.2 (or other HAI version) would be needed to run

Cracked

Perl 5, A007094 (Cracked)
Numbers in base 8
Byte set sub {if($_[1]!=%/)ret-n;}
Try it online!

Two r in your byteset

I like how your byteset as-is looks like valid Perl.

Cracked.

Octave, A000045
This produces the Fibonacci numbers, OEIS A000045. There's both a space and a newline in there.
It's 0-indexed, so input 0 gives 0.

 ()-;=>cdefinotu

Cracked.

JavaScript, A000004 (Cracked)
Look from the other side
at~N+1

Step Hen's solution

 ~NaN+1

My solution #1

 ~1+1+1

#2

 ~~NaN

Cracked (at least for Chrome console)

Ly, A005150, Cracked
!$+-012<=>JS[]lnprsu

Well. Let's see how this plays out.

I wanted to continue working on it, but you added a -, therefore: cracked. Nice way to promote your language!

cQuents, A033307, Safe
Fe_pz:"/`'-2;
Try it online!
Explanation:

 ":z--F_p-2
Try it online!
": means a char sequence; basically, the output needed. Now, we need to just get the current index, which would usually be $. z starts out as 0 and is the previous number from then on, so we need just to add one to it. -- is the equivalent of +, and F_p-2 means Floor(Pi-2), which works.

JavaScript (ES6), 4 bytes, A005408 (Cracked)
This should be an easy one. Odd numbers: a(n) = 2n+1
Byte set:
$+=>

Cracked! (I hope, it's my first Cops & Robbers answer)

CJam, A000142, 8 bytes, Cracked
Byteset: {}*+)%1\

Cracked

dc, A028444 (cracked)
-?/*+23568dpr
There are no spaces in the byte set, but that’s not a big deal for dc.
Sequence is indexed at 0.
Note: Rado’s Sigma function grows faster than any computable function and is thus noncomputable!

Intended solution: ?dddddd***3*rdd**22*-rd*53*+r26*-8/p

Cracked.

CPython 3.6.2, A000796 (cracked)
I like Latin-1. Here's another 70 characters.
,Ðûô[u÷ÎÆ»énb¤Äö]?có´å¡ùÇõÓ«;Ñ$èñÙdÁ¼
¢üÔltsð½(þÚ#ä.×çÈýÅ§ã¯\)³íï¬Â±¥_Ê=iÌ

This bunch of characters can calculate the decimal digits of pi. Surely this requires flow control. And yet there isn't a colon, so that is impossible. You can't even eval a string when there is neither eval nor a string.
I'll give a hint: my program takes input from stdin and outputs to stdout, but I am almost completely certain that it is possible to use other I/O methods.

For anyone wondering, the available ASCII chars are #$(),.;=?[\]_bcdilnstu and newline, and the non-ASCII ones are ¡¢¤¥§«¬¯±³´»¼½ÁÂÄÅÆÇÈÊÌÎÐÑÓÔ×ÙÚãäåçèéíïðñóôõö÷ùûüýþ.

@ETHproductions Now you've spoiled it! :-) At least it makes my love of FreeBSD clear.

It's really not hard to sort the charset... :P Now I'm thinking this must be a template of some sort, since your other answer uses exactly the same ASCII set. I don't know zip about why you would be so specific about CPython 3.6.2 though, so I'll leave that to the Python experts...

@ETHproductions It's because the subset I've chosen is Turing complete. It's because I'm not about to claim that it works in a version that I haven't tested it in, and I've been very hackish.

@ppperry I felt like that many, many times. It took me two days to work out a solution, and I knew what I was going for to start with!

@ppperry You have è and é, if that helps. :-)

Cracked, almost twice as long as the other two cracks.

@ppperry Amazing. I've just realised that I forgot to upvote your cracks. They definitely deserve it.

shortC, A000240, 64 bytes
Uses the characters in this ASCII map:
    "     %     ( ) * + , -
  1 2                       >
@ A         F     I
    R   T             [   ]
  a     d         i         n o
p       t     w       {   }

Map credit: ETHproductions

By far the most random place I've ever found myself given credit for something :P

Perl 5 -n, A000290: the squares, score:18, safe.
 ;cdeghijklnopqrst

Rules

Input from stdin, as a string of decimal integer.

Intended solution

 int or print;int or die;int ne length q q q or print;int ne length q q q or die;s ss s;chr sqrt length eq chr or redo;print length

 Try it online!

 Usage: from stdin, as a decimal integer. 0-indexed.
 Can accept only a line.
 Input shall match /^\d+$/.
 No trailing LF to your input.
 Output from stdin, as decimal integers.
 If your input is 0 or 1, the program dies but please don't care for such thing; this specification is just for this challenge.

JavaScript (ES6), 10 bytes, A000007
Byte set: -)$>yRa=A(

OEIS is currently down, so for anyone looking, A000007 is a(n)=0^n, which is 1,0,0,0,0,0,0,0,....

Cracked!

Cracked with 6 bytes

R, A000027 (Cracked)
An easy one to warm up :)
Byteset:
eiytnd

Solution:

 identity returns the input, so maps n to n.

Cracked?

@Shaggy Wouldn't that just return the integer? Shouldn't it return a whole sequence? Or maybe Jarko misunderstood?

@MrXcoder: Or maybe I did! :D

It should return the nth entry, so this works.

Python 2, 24 bytes, A001246, cracked
Byte set:

 )(+*-/12:=<acbdfmlonrx

Try it online!

Cracked

Agh, no fair. :P

Python 2, 21 bytes, A157433, cracked

6ut1 28rp5=)ni+03(*7

Try it online!
Original solution:

n=input()
print 128*n**2+2336*n+10657

Probably super easy, but eh, I have =).

Cracked.

Well, I had already posted this, so double cracked.

Seed, A000027 (Counting Numbers) (Cracked)
You may use any valid character in Seed:
[0-9 ]

Have fun! The resulting Befunge program is short, so you should definitely be able to brute force it within a week (if you're crazy enough to do that).
My Solution:
My solution is a little bit longer than Lynn's solution...
4 [encoded data, 6011 characters]

Can you link an online interpreter? I can't seem to find one

@Azulflame There's no interpreter because the language is converted to Befunge before being interpreted. Use the python script provided on esolangs.org and TIO's Befunge-98 interpreter.

Gotcha. Only took about a minute of bruteforcing on my laptop!

@Lynn Nice job! I knew I should have gone with a more complex series :P

@Lynn Care to try a harder one?

Jelly, 16 bytes, A000042 (Cracked)
Byte Set:
%1@JOiv¤ØȷḌṁị“”€

(The two quotes are different: one is opening and the other is closing).
(uses Jelly codepage)
The sequence is: a(n) is the unary representation of n.

This challenge requires you to submit a character set to use rather than a list of characters

Cracked.

Well a character set rather than list makes this quite a bit easier.

Python 3, 19 byteset, A000290, Cracked
This is the perfect squares: 0, 1, 4, 9, ....
Byteset:
(fam, l+db-ise=10:)
Note: I had two iterations with duplicate characters (and missing characters) because I'm dumb.
My solution (not very efficient):

 f=lambda l,a=1,b=0:f(l-1,a+1+1,b+a) if l else b

Try it online!

Why are there two as in the byteset

@ppperry my bad, sorry. Fixed.

still two 1s.

@ppperry I don't know why this was so hard - I believe it's fixed now, so sorry 0.o

Cracked!

@Lynn and you did it even without a , because I screwed up my byteset. Good job! Editing in mine.

MATL, 11 bytes, A000984
Uses some of these bytes (ASCII):
$&)+/:HZdep

Due to floating-point precision, results are only guaranteed to be accurate up to the 26-th term. I hope that's acceptable.

Ruby, A000217, 15 bytes, Cracked
Uses the -p flag to take input from stdin and output to stdout.
$mu.to_vim[d=s]

Intended solution:

 $_=[$...$_.to_i][$..div$$].sum

Cracked.

C, A000312 (cracked)
-,;:?(){} eglnortu
The specs call for a complete program, however this would add many more characters to the byte set making the challenge trivial. Instead, you’ll be providing the code within this template:
«your-code-composed-of-characters-in-byte-set»

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char** argv)
{
    int n = argc > 1? atoi(argv[1]): 0;
    printf("%d ^ %d = %lld\n", n, n, «your-function-name»(n));
    return 0;
}

Note that your code comes before the #includes.

 Answer: long long l(long long o,long long n){return o- -n;} long long o(long long n,long long g){return g?(--g?l(o(n,g),n):n):g;} long long n(long long g,long long l){return l?o(n(g,--l),g):- --l;} long long g(long long l){return n(l,l);} Addition l is expressed as subtraction of a negated value m + n = m − (−n), multiplication o as a series of additions m × n = m × (n − 1) + m, exponentiation n as a series of multiplications mⁿ = mⁿ⁻¹ × m, and finally the function g which calls the exponentiation function. On machines where long long is 64 bits wide, this code will give incorrect answers for n ≥ 16, but note there are machines out there with word lengths of more than 64 bits, e.g. the Ethereum Virtual Machine (EVM) with 256-bit words where long long could naturally accommodate values ≫ 2⁶⁴. So in theory the code would work for n ≥ 16.

Cracked

@ChristianSievers - Great work!

Your code has an unlucky combination of o recursing on the second argument, and n calling o in a way such that the second argument is potentially much bigger than the first. If you avoid this, you will see your numbers overflowing long before your stack does.

Thanks for that! Have reordered the parameters and revised the spoiler.

Haskell, A001107 (cracked)
This one is easier, the sequence is growing slower and the charset is smaller.
Compute the decagonal numbers n(4n-3) using the following charset of size 9:
.,_-=[ ]!

Again there is no newline.

cracked

CPython 3.6.2, A000720 (cracked)
I have decided to squeeze as many characters out of Latin-1 as possible without simplifying the challenge. There are some unprintables, so I will provide the characters in the following format:
print(",".join((
    "0x0-0x8",
    "0xa-0x1f",  #inc. \n
    "0x23-0x24",  # chars #$
    "0x28-0x29",  # chars ()
    "0x2c",  # char ,
    "0x2e",  # char .
    "0x3b",  # char ;
    "0x3d",  # char =
    "0x3f",  # char ?
    "0x41-0x5d",  # A-Z and chars [\]
    "0x5f",  # char _
    "0x62-0x64", # chars bcd
    "0x69",  # char i
    "0x6c",  # char l
    "0x6e",  # char n
    "0x73-0x75", # chars stu
    "0x7f-0xff"
)))

I think that makes 208 characters. Feel free to use any of these.
I did not hard-code; that would take so many characters I would have to start meta-meta-programming. This set of characters is provably Turing-complete.

Why the downvote? Dennis did a similar thing.

I wasn't the downvoter, and I don't think this is why the downvote, but couldn't you just say "I used 0x0-0x8,0xa-0x1f,0x23-0x24,0x28-0x29,0x2c,0x2e,0x3b,0x3d,0x3f,0x41-0x5d,0x5f,0x62-0x64,0x69,0x6c,0x6e,0x73-0x75,0x7f-0xff"?

@MDXF I could, but then there wouldn't be the comments explaining what the characters were and people would have to manually look things up or write a program to get the printable characters out of it. (I admit that my "format" isn't the best, though.)

cracked verbosely. Sorry, I posted this on the wrong cop answer previously.

Python 2, A005150 (Look and say), safe
 "()+,.01:=ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]_celnortwx

Gee, you don't didn't have much, do did you?
Intended solution:

 exec("FROM ITERTOOLS IMPORT GROUPBY\nA=\"1\"\nFOR _ IN RANGE(1,INT(INPUT())):\n\tA=[\"\".JOIN(GRP)FOR M,GRP IN GROUPBY(A)]\n\tA=\"\".JOIN([STR(LEN(X))+X[0]FOR X IN A])\nPRINT(A)".lower()) You have all of the uppercase characters, and just enough lowercase ones for \n, \t, exec and lower.

Perl 5 -p, A005843, score:16, safe.
 .0123456789aelv

A simple problem. You should solve this easily if you are familiar with the language well.
Intended solution

 eval 36.95.42.61.50

 How it works: version number such as 5.10.3 is represented as a string.
 So, you just need to construct a version number to be evaluated.
 Example: v33 is '!'.

CLC-INTERCAL 1.-94.-2, A001477, safe, score: 16.
Byteset:
@ABDEHIP`abdehip

You may use any i/o method.
Also you may use any compiler option.
Try it online! Submitting as CLC-INTRCAL does not let you set compiler option, so you might need to try as shell.
The answer
D`h@I@`P@pAB@d@p`DPb@PD`h@`P@d@aD`h@E@ABPb@P

This is equivalent to DOWRITEIN.1DOREADOUT.1 in Hollerith character set; so input range is OH or ZERO to SIX FIVE FIVE THREE FIVE (inclusive).
Try the following Bash script online:
printf 'D`h@I@`P@pAB@d@p`DPb@PD`h@`P@d@aD`h@E@ABPb@P'>.i;sick -h .i;./.io

How it works
The code can be in Hollerith character set. However, it is implemented incorrectly so the code above is for such behaviour as in implementation, not for documentation.
Here is the script to accept punch lines to generate a program in Hollerith.
Also why doesn't the compiler guess anything other than ASCII? So I had to force it to use my intended character code, by -h.
See also
My answer on Print X without X

CLC-INTERCAL, A001477, safe, score: 14.
Byteset:
ACFGIJLPRWX[\_

Rules

You may use any compiler option.
You may specify i/o format by yourself.
You may specify range of input.
You may specify whether 0-indexed or 1-indexed.
I made a program that works on this online environment.

Answer
IXRJFPAFL[\W_IXJACIXGP[\W

This is DOWRITEIN.1DOREADOUT.1 in Baudot encoding, so input range is OH or ZERO to SIX FIVE FIVE THREE FIVE.
Due to the encoding, you need compiler option -b if it is newer so the character guessing does not work.
Try the following Bash script in online environment
printf %s 'IXRJFPAFL[\W_IXJACIXGP[\W'>.i
sick -b .i
./.io<<<'THREE FOUR FIVE'

Copy and paste to try it online!
See also

My problem that requires Hollerith encoding
My problem that requires EBCDIC encoding

Javascript (ES6), A000079, 6 Bytes
[]()+!

Hint:

 Intended solution is 25496 characters long.

Cracked

@L3viathan Close enough. :) I'd actually used $=>Math.pow(2,$), but you had the right idea. JavaScript is weird.

all_licenses: 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/