hyacinth's stats

for(local a=array(999,0),i=0,d;i++<250;){d=a[i-1];a[i]=d+(d-i<1||a.find(d-i)?i:-i);print(d+"\n")}

import "random" for Random

var random = Random.new()

var steps = 100 // change this to alter how many steps the simulation makes

var particles = 2 // change this to alter how many particles are simulated

var gravConstant = 1 // change this to affect the effect of gravity on the particles

var gridSize = 16 // change this to adjust the resolution of the simulation

var particleMasses = []
var Xpos = []
var Ypos = []
var Xvel = []
var Yvel = []

for(i in 0...particles){

	particleMasses.add(random.float(6))
	Xpos.add(random.float(-0.5, gridSize - 0.5))
	Ypos.add(random.float(-0.5, gridSize - 0.5))
	Xvel.add(random.float(-0.5, 0.5))
	Yvel.add(random.float(-0.5, 0.5))

}

for(i in 0...steps){

	// drawing

	var displayChars = "`<*3P#@"

	var outputGrid = []

	for(j in 0...gridSize + 2)outputGrid.add([" "] * (gridSize + 2))

	outputGrid[0][0]="+"
	outputGrid[0][gridSize + 1]="+"
	outputGrid[gridSize + 1][0]="+"
	outputGrid[gridSize + 1][gridSize + 1]="+"

	for(j in 1..gridSize){

		outputGrid[0][j]="-"
		outputGrid[gridSize + 1][j]="-"
		outputGrid[j][0]="|"
		outputGrid[j][gridSize + 1]="|"

	}

	for(j in particles-1..0){ /* loop through in reverse so
	particles earlier in the particle list are rendered
	over particles later in the list */

		var particleChar = displayChars[particleMasses[j].round]
		var rawX = Xpos[j].round
		var renderedX = 1 + ( rawX < 0 ? -1 : rawX > gridSize - 1 ? gridSize : rawX )
		var rawY = Ypos[j].round
		var renderedY = 1 + ( rawY < 0 ? -1 : rawY > gridSize - 1 ? gridSize : rawY )
		outputGrid[renderedY][renderedX] = particleChar

	}

	System.print("Iteration %(i)")
	for(j in 0...gridSize + 2)System.printAll(outputGrid[j])
	System.print()

	// computing

	var xVelDeltas = [0] * particles
	var yVelDeltas = [0] * particles

	for(affectedParticle in 0...particles)for(affectingParticle in 0...particles)if(affectedParticle != affectingParticle){

		var xDelta = Xpos[affectingParticle] - Xpos[affectedParticle] 
		var yDelta = Ypos[affectingParticle] - Ypos[affectedParticle] 

		var radiusSquared = xDelta.pow(2) + yDelta.pow(2)

		var distanceBetween = radiusSquared.sqrt

		var forceMagnitude = gravConstant * particleMasses[affectedParticle] * particleMasses[affectingParticle] / radiusSquared

		var xAccel = xDelta / distanceBetween * forceMagnitude
		var yAccel = yDelta / distanceBetween * forceMagnitude

		xVelDeltas[affectedParticle] = xVelDeltas[affectedParticle] + ( xAccel < -gridSize / 2 ? -gridSize / 2 : xAccel > gridSize / 2 ? gridSize / 2 : xAccel ) 
		yVelDeltas[affectedParticle] = yVelDeltas[affectedParticle] + ( yAccel < -gridSize / 2 ? -gridSize / 2 : yAccel > gridSize / 2 ? gridSize / 2 : yAccel ) 


	}

	for(j in 0...particles){

		Xvel[j] = Xvel[j] + xVelDeltas[j]
		Yvel[j] = Yvel[j] + yVelDeltas[j]

	}

	for(j in 0...particles){

		Xpos[j] = Xpos[j] + Xvel[j]
		Ypos[j] = Ypos[j] + Yvel[j]

	}


}

o

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.

import urllib.request,tarfile,os,random,re
b = urllib.request.urlopen("https://cg.esolangs.gay/49.tar.bz2").read()
with open("hentai.txt", "wb") as binary_file:
    binary_file.write(b)
a = tarfile.open(name="hentai.txt", mode='r:bz2')
e = str(random.randint(0,10**10))
a.extractall(e)
a.close()
b = os.listdir(e+"/49")
f=[]
g=[]
h=[]
for i in b:
    c = os.listdir(e+"/49/"+i)
    print(c)
    if "entrrui.py" in c:
        continue
    if len(c) == 1 and bool(c[0].endswith(".py")):
        f += [i]
    elif len(c) == 1 and "." in c[0]:
        if c[0].index(".") not in (0,len(c[0])-1):
            g += [i]
    
    else:
        h += [i]
print(f,g,h)
exit()
path = e+"/49/"
if f:
    p = random.choice(f)
    path += p + "/" + os.listdir(e+"/49/"+p)[0]
    d = open(path,"r")
    w = d.read()
    d.close()
    exec(w)
elif g:
    p = random.choice(g)
    path += p + "/" + os.listdir(e+"/49/"+p)[0]
    d = open(path,"r")
    w = d.read()
    d.close()
    print("run this cuz i ain know how:\n")
    print(w)
else:
    P = urllib.request.urlopen("https://www.biostat.wisc.edu/~annis/creations/PyLisp/lisp.py").read()
    exec(P)

def feelma ( deez : str , nuts : str ) -> tuple ( [ int , int ] ) or None:
    candice = [ ]
    ligma = len ( nuts )
    sugondese = len ( deez )
    for joe in range ( sugondese ):
        for mama in range ( 1 , sugondese ):
            try:
                doomah = ""
                for kenya in range( ligma ):
                    doomah = doomah + deez [ joe + mama * kenya ]
                if doomah == nuts:
                    return ( joe , mama )
            except:
                pass# deez nuts into your face
    return None
    
def entry ( haystack : str , needle : str ) -> tuple ( [ int , int ] ) or None:
    return feelma ( haystack , needle )

console.log("guess the api lmfao")

a = prompt().split(" ");
b = [];
c = 0;

while (c < a.length) {
	if (a[c] != "") {
		b.push(a[c]);
	};
	c++;
};

d = 0;
e = [];

while (d < b.length) {
	f=Number(b[d]);
	if (/^[0-9]*$/.test(f)) {
		e.push(f);
	};
	d++;
};

var f = function(g) {
	if (g.length == 0) {
		return [[]];
	} else if (g.length == 1) {
		return [g];
	} else {
		h = f(g.slice(1));
		i = 0;
		j = [];
		while (i < h.length) {
			if (g[0] < h[i][0]) {
				j.push([g[0]].concat(h[i]));
			};
			i++;
		};
		j.push([g[0]]);
		return h.concat(j);
	};
};

k = f(e);
l = 0;
m = 0;

while (l < k.length){
	if (k[l].length > m) {
		m = k[l].length;
	}
	l++;
}

n = 0;
o = [];

while (n < k.length){
	if (k[n].length == m) {
		o.push(k[n]);
	}
	n++;
};

p = 0;
while (p < o.length) {
	q = 0;
	while (q < o[p].length){
		process.stdout.write(o[p][q].toString()+" ");
		q++;
	};
	p++;
	console.log("|");
};

g="";a=input("".join([chr(ord(q)//127)+chr(ord(q)%127) for q in"⊩㧱㢮㧴㈻ㇽ㧭ၗ㒋㎸㦂ㆀ㊎㥶㫯၅㜆㣷㊎၉㚲㣽㭼ၓ㊋ゑん㉿၂㰧㫯㤂㑺る၂ゑ㤭ᑔᑷろㆼ㭲㧴ၔ㏽ၒ㞈㤭㧴㊈㥲㘊㊎ၓ㊋ゑん㉿၂㰧㛷㭵㒅㊎ᛜ⨔㈻㗵㄃㖴㣽㬩㥵㞆㗸၂㈻㧴㈻㌃㤁㦬㣽㬩㊉㧱㣳㇊အ㌎㊍၉㜂㩿㧵㛹ၔ㏽၆㒅るၒ㞈၏㊺ㇽ㧭ᗴ㠂㊎㤭㊉㧱㢮㨃㑺㉉Ԁ₭၅㯩㚃㗹၏㊺ㇽ㧭၉㚲㧴㈻ㆌ㤀㉾㦬㌉㣻ん၉㤭を၆㝽㘃㭼᳐㈘㊗〩㌖㌖㐡㌖㈘㞚㤊㈘㐡խ㏽㣳ၔ㏽ဂㆾᗴᅃᄊ၁㛶ဂぁ၉㚲㧴㈻㌃㤁㦬㣽㬩ゑ㈻㧴㈻㗵㄃㘇ᛜՊ㏽ၐ㣽㎋れၗ㒃㖴㣳㨁㣼၉㛵㞃㣳㆑ၒ㊎㩷㧿၉㊺㈑㟼㑺ん㈻㗵㄃㘇၁㣳ၕ㥲ㆼᑏ㐁ㆅၙ㞆ၐ㣽ヿㄊ㰧㥵㞆㗸㚹㦬㏹㫯၉㚲㱶㩽၄んめを㈻ろ㱾゘㤶Ԁ"]))
while a:g+=a+"\n";a=input()
g=g.split("\n")[:-1]
def o(n):return o(n-1)+[i+[n-1]for i in o(n-1)]if n else[[]]
if len(g)<3:print("Oops, not enough rows...");exit()
h=[i.split("|")for i in g]
if len(h[0])==1:print("Oops, not enough columns...");exit()
q=[[(G[K],h[0][K])for K in range(len(G))]for G in h[1:]]
J=[[[j[Q]for Q in i]for j in q]for i in o(len(q))]
X=[H for H in J if[H.count(l)for l in H]==[1]*len(H)]
W=[set([w[1] for w in x[0]]) for x in X]
if not W:print("Oops, no candidate keys...");exit()
F=[list(f) for f in W if len([p for p in W if p.issubset(f)])==1]
print("\n".join(["|".join(S) for S in F]))