I always like technology since I was a kid. I used to know my shit for my age but now I don't really know much.
How do I learn more about hardware (processors mobo etc..) and software? For example, I want to be able to figure out the best pc build in terms of power or value with best compatibility.
I did build my own pc recently but that's as simple as following a yt video and choosing parts with pcpartpicker
111112221
Retard
312211
My bad I meant
111112211
Should it be 132211?
No
Start :
1
There's one 1, so the next is : 11
Now, there's two 1 so the next is : 21
Now, there's one 2 and one 1, so the next is : 1211
...
So shouldn't it be
12411
Then?
1211 :
1 one (1), 1 two (2), 2 one (1)
111221 :
3 one (1), 2 two (2), 1 one (1)
312211
/thread
This
It's "312211".
>en.wikipedia.org
"111221" reads as:
31 ("3 times 1")
22 ("2 times 2")
11 ("1 time 1")
that's fucking cool tbqh
The three should sandwich with the 2s though
Can this be predicted indefinitely without saying the numbers?
teach your computer to say numbers out loud
Probably. You only need to store the numbers in an array and keep count of the number of times you get a sub list of numbers when reading the array in a left to right fashion.
So [1] would be an array of length one containing a 1.
Turn that into [count,one]
Then we get [1,1]
Count on the ones is two 1s.
Turn that into [count-ones,1]
Then we get [2,1]
Then count unique numbers again
[Count-2s, 2, count 1s, 1]
Turns into [1,2,1,1]
And so on.
Or we can just go with:
2211111211
:^)
You can do it functionally.
>tfw OP derailed his own thread in the opening post
Lmao I realise my mistake
At first we define a data structure (for example a "linked list") where each element points to his successor, for example: "111" gets "31". There are 92 elements (according to Wikipedia).
Then we need a recursive function which takes f(n-1) and splits it at the points where the numbers change. Each elements's successor is looked up and put together.
Not that difficult, actually.
> (for example a "linked list")
Ah shit, this is nonsense.
We need no linked list, we need a simple map:
The keys are the parts of the sequences, the values are the successors:
>map = {1: 11, 11: 21, 111: 31, 2: 12, 22: 22, 222: 31, 12: 1112, ...}
Then it's just one lookup for each part of the sequence..
I can see it's a fibonacci sequence but wtf how does digits should be placed
Ah well, I feel sorry for you..
Oh, the link was a little bit old, this looks promising:
>web.info.uvt.ro
Guys, I did it:
# Ruby ftw
def next_Number (a)
a = a.to_s.split(/([1]+|[2]+|[3]+)/).reject {|e| e.empty?}
a.map{|e| e.length.to_s
Tested it:
tmp = 1
1.upto(10) do
puts tmp
tmp = next_Number (tmp)
end
# Output:
#1
#11
#21
#1211
#111221
#312211
#13112221
#1113213211
#31131211131221
#13211311123113112211
I know nobody cares, but I made a clear version.
I'm sorry that the RegEx is so bad, otherwise I wouldn't have to throw out the empty strings afterwards..
tmp = '1'
(1..10).each do
puts tmp
tmp = tmp.split(/([1]+|[2]+|[3]+)/)
.reject {|e| e.empty?}
.map{|e| e.length.to_s