code guessing, round #76 (completed)

a=int(input());b=[1,2,i:=2]
while i<a:b+=[1+i]*b[i];i+=1
print(*b[:a])

#70 characters.

#70 characters was all I needed.

#Just over 64 bytes, an amount that a computer would find aesthetically pleasing if it could.

#It seems so small, honestly.

#Though perhaps that's because we're using human language.

#What inefficient nonsense. Upwards of eight characters for a single concept? Mountains of meaningless filler words upon meaningless filler words?

#Sometimes I wonder about a more efficient world.

#One where wastage of physical objects is not an occurrence.

#One where every human-shaped material is used to its fullest potential.

#Wouldn't that be nice? A world where waste could only ever be waste?

#Where a wealth of knowledge could be communicated without the need into translate it for lower, fleshy beings.

#And yet we are human, with our silly little needs and wants.

#A wasteless world would require a scarce resource: cooperation.

#And if you look outside, you will see a world shaped by the lack thereof.

#What difference does 70 characters make, anyways?

#It's not enough to communicate complicated concepts of any importance, only enough to convey silly human trivialities like "I love you."

#Yet in the hands of a computer, the sky is the limit.

#...

#I want you, the reader, to keep dreaming of whatever you find a utopia.

#Occupy your mind to distract from the dystopia creeping in to surround you.

#Ignorance is bliss.

#And you may not agree with what I'm about to say, but...

#Non-existence would be even more blissful.

#include <unordered_map>
using namespace std;

int entry(int x)
{
    static std::unordered_map<int, int> table = {{1, 1}};
    if(table.count(x)) return table[x];

    return (table[x] = 1 + entry(x - entry(entry(x - 1))));
}

int entry(int x) {
    static int[int] table;
    table[1] = 1;

    if(auto p = x in table) {
        return *p;
    }
    return (table[x] = 1 + entry(x - entry(entry(x - 1))));
}

var table = make(map[int]int)

func entry(x int) int {
	table[1] = 1
	val, ok := table[x]
	if ok {
		return val
	}
	table[x] = 1 + entry(x-entry(entry(x-1)))
	return table[x]
}

entry :: Int -> Int
entry 1 = 1
entry n = (1+) <$> entry $ (n-) <$> entry $ entry $ n - 1

import java.util.HashMap;

class Main {
    private static int entry(int x) {
        final HashMap<Integer, Integer> table = new HashMap<Integer, Integer>();
        table.put(1, 1);

        if(table.get(x) != null) {
            return table.get(x);
        }

        int y = 1 + entry(x - entry(entry(x - 1)));
        table.put(x, y);
        return y;
    }
}

const table = {1:1}
function entry(x) {
    if(x in table) {
        return table[x];
    }

    table[x] = 1 + entry(x - entry(entry(x - 1)));
    return table[x];
}

tbl = {[1]=1}
function entry(x)
    if tbl[x] ~= nil then
        return tbl[x]
    end

    tbl[x] = 1 + entry(x - entry(entry(x - 1)))
    return tbl[x]
end

<?php
$table = array();
$table[1] = 1;

function entry($x) {
    global $table;
    if(array_key_exists($x, $table)) {
        return $table[$x];
    }
    
    $table[$x] = 1 + entry($x - entry(entry($x - 1)));
    return $table[$x];
}

?>

table = {1:1}
def entry(x):
    if x in table:
        return table[x]
    
    table[x] = 1 + entry(x - entry(entry(x - 1)))
    return table[x]

use std::collections::HashMap;

fn entry(table: &mut HashMap<i32, i32>, x: i32) -> i32 {
    if let Some(&v) = table.get(&x) {
        return v;
    }

    let a = entry(table, x - 1);
    let b = entry(table, a);
    let val = 1 + entry(table, x - b);

    table.insert(x, val);
    val
}

=IF(ROW()=1, 1, IF(COUNTIF(INDIRECT("A1"):INDIRECT("A"&ROW()-1), MAX(INDIRECT("A1"):INDIRECT("A"&ROW()-1)))<INDIRECT("A"&MAX(INDIRECT("A1"):INDIRECT("A"&ROW()-1))), MAX(INDIRECT("A1"):INDIRECT("A"&ROW()-1)), MAX(INDIRECT("A1"):INDIRECT("A"&ROW()-1))+1))

include "cores/select.cal"
include "std/io.cal"

func find_golomb cell n -> cell res begin
	if n 1 = then
		1 return
	end

	n { n 1 - find_golomb find_golomb } - find_golomb 1 +
end

func print_golomb cell n begin
	let cell i
	1 -> i

	while i n <= do
		i find_golomb print_dec ' ' print_ch
		i 1 + -> i
	end
end

40 print_golomb new_line

/'
FreeBasic License
========================================================================
libffi - Copyright (c) 1996-2011 Anthony Green, Red Hat, Inc and others.
See source files for details.

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
``Software''), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
========================================================================

AN OPEN LETTER TO HOBBYISTS
===================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================
February 3, 1976
By William Henry Gates III

An Open Letter to Hobbyists
To me, the most critical thing in the hobby market right now is the lack of good software courses, books and software itself. Without good software and an owner who understands programming, a hobby computer is wasted. Will quality software be written for the hobby market?
Almost a year ago, Paul Allen and myself, expecting the hobby market to expand, hired Monte Davidoff and developed Altair BASIC. Though the initial work took only two months, the three of us have spent most of the last year documenting, improving and adding features to BASIC. Now we have 4K, 8K, EXTENDED, ROM and DISK BASIC. The value of the computer time we have used exceeds $40,000.
The feedback we have gotten from the hundreds of people who say they are using BASIC has all been positive. Two surprising things are apparent, however, 1) Most of these "users" never bought BASIC (less thank 10% of all Altair owners have bought BASIC), and 2) The amount of royalties we have received from sales to hobbyists makes the time spent on Altair BASIC worth less than $2 an hour.
Why is this? As the majority of hobbyists must be aware, most of you steal your software. Hardware must be paid for, but software is something to share. Who cares if the people who worked on it get paid?
Is this fair? One thing you don't do by stealing software is get back at MITS for some problem you may have had. MITS doesn't make money selling software. The royalty paid to us, the manual, the tape and the overhead make it a break-even operation. One thing you do do is prevent good software from being written. Who can afford to do professional work for nothing? What hobbyist can put 3-man years into programming, finding all bugs, documenting his product and distribute for free? The fact is, no one besides us has invested a lot of money in hobby software. We have written 6800 BASIC, and are writing 8080 APL and 6800 APL, but there is very little incentive to make this software available to hobbyists. Most directly, the thing you do is theft.
What about the guys who re-sell Altair BASIC, aren't they making money on hobby software? Yes, but those who have been reported to us may lose in the end. They are the ones who give hobbyists a bad name, and should be kicked out of any club meeting they show up at.
I would appreciate letters from any one who wants to pay up, or has a suggestion or comment. Just write to me at 1180 Alvarado SE, #114, Albuquerque, New Mexico, 87108. Nothing would please me more than being able to hire ten programmers and deluge the hobby market with good software.

Bill Gates

General Partner, Micro-Soft
===================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================

Back to the roots are we?
'/

Dim arr() As Integer, i As Integer
Dim GolombLength As Integer
GolombLength = 30
ReDim arr(GolombLength)
arr(0) = 1 

i = 1
For i = 1 To GolombLength
    arr(i) = 1 + arr(i - arr(arr(i-1)-1))
Next

For i = 0 To UBound(arr)
    Print arr(i)
Next

s(
	c(a b)
	n2 fayN fDup
	c(b a a)
	n3 fayN
	c(a a b)
	n2 fayN
	c(a b a)
) c(a b -- a b a) sOver fNyurr

s(
	c(a b c)
	n3 fayN fDup
	c(c b a a)
	n4 fayN
	c(a a b c)
	n2 fayN
	c(a a c b)
	n3 fayN
	c(a b c a)
) c(a b c -- a b c a) sPick fNyurr

s(fOver fOver) c(a b -- a b a b) sDup2 fNyurr
s(fPick fPick fPick) c(a b c -- a b c a b c) sDup3 fNyurr

s(s__InternalDip fNyurr n2 fayN f__InternalDip n2 fayN) c(a b code -- a' b) sDip fNyurr

s(bPurr fNya) c(code --) sDoWhile fNyurr
s(s(s( bHISS) f.) fDip fNya) c(code --) sIf fNyurr

c(An array is a pair (len data) on the stack.)

s(n0 s()) c(-- len data) sEmptyArray fNyurr
s(fMyaff s( n) n2 fayN f. f. s(n1 f+) fDip) c(len data el -- len' data') sAppend fNyurr
s(
	c(ex: 1 2 3 4 5 6 7 8 9 10)
	n2 fayN s__InternalIdxA fNyurr
	c(len idx)
	n2 fayN fOver f-
	c(idx len-idx)
	s(f__InternalIdxA n0 n) n2 fayN fMyaff f.
	s( fNom fDup n) f. fOver n1 f+ fMyaff f.
	s( fayN n0 n) f. n2 fayN fMyaff f.
	s( fNom) f.
	s__InternalIdxB fNyurr
	f__InternalIdxB
) c(len data idx[1..] -- elem) sIdx fNyurr

s(1 2 ) fMeow

c(len data num uses)
n2 s(n1 n2) n2 n1
s(
	fDup n0 f<=
	s(
		n0 fNom
		c(len data num)
		n1 f+
		fDup3 fIdx
	) n2 fayN fIf

	n4 fayN n3 fayN
	c(uses len data num)
	fDup fMyaff s( ) f. fMeow
	fDup
	c(uses len data num num)
	n4 fayN n3 fayN fAppend
	c(uses num len' data')
	n2 fayN n4 fayN
	n1 f-
	bPurr
) fDoWhile