Nop, the article is false about this. The optimal algorithm is O(n) as you can make a simple regular expression that is the Kleene star of an or of all the words in your dictionary to match the input. This is allowed as you can choose how to implement the dictionary, it don’t take more space than a trie and match in linear time as it can be compiled to an NFA or a DFA.
The DFA is O(n) with up to exponential time spent upfront (and exponential space usage too). The exact complexity for the NFA with the regex you suggest depends on how the NFA is built, but it is at least O(n^2) worst case because you can easily build a case with n active states. Likewise for the lazy DFA.
It works the other way, the shooter position is fixed as well as your position. Your are allowed to place a finite amount of blockers to make your position safe. The video comment say that it is always possible to make your place safe with at most 16 blockers.
There is a link to the actual code used.
There is nothing here close to sign language translation. Hand gesture are a very small and quite easy part of sign language who involve all the upper part of the body and face and use a lot of context and placement in space.
Yep this is fingerspelling, a small part, used for names and things there aren't signs for.
Here's an instructor running at medium speed for clarity. Experts go faster, drop more letters bcs cn undrstd wthout thm, and combine motions, like dipthongs.
But I'm in their target market and I don't want a replaceable battery. I just want the battery to be serviceable when it wear.
For a given phone size, a replaceable battery require some additional space which means it will be smaller than a non-replaceable one.
I don't want to buy one or two additional battery to carry with me when I can get a battery that last a bit longer and that I can charge with any power bank. (mine or the one of a friend as there is no compatibility problems)
Users who want replaceable battery are niche in the niche.
I highly doubt this phone is going to win the thinness wars anyway, so the space savings aren't going to be as relevant. It would be much smarter to differentiate themselves on features such as replaceable batteries, which the mainstream market has ignored precisely because they want to chase thinness.
The real question is, how many users want replaceable batteries, and is there enough overlap between that group and the audience for an OSS phone. I would imagine the overlap is significant, but without market research on the subject I don't know if I'm right.
Then, how do you explain that the last update improved performance a lot on older devices ? Last time I've checked there was no hardware upgrades in the downloaded update...
This si full FUD and I don’t known the author objective. Those satellite will be in low orbit where one of there big problem will be to keep theire orbit. Their end of Life depend on how much fuel they have, and when they have no more fuel they decay. Or takes only some months (or at most a des years for the ones in higher orbit) to burn in the athmospher.
The only problem Witness so much satelite in low orbit si tracking them during their life which us easy for thoses as they require precise tracking for being operational.
But this device doesn't need a way for the user to enter the pincode. So, all the sensitive part of the terminal is probably completely isolated from the android part.
I don't know this device internal and the PED/PTS exact requirement but it seems plausible for me.
You have something like a physical compartment who include the NFC and everything needed to process it like in a classical terminal. This compartment is highly secured as requested by the specification with just a very simple interface for the android part to send the amount to bill.
I've seen a lot of each-machine running on windows. Doesn't they work like this with the windows machine just managing the display buttons to select the amount and sending this information to the secure part who handle card interaction, pincode and delivery of the money ?
Yes this is a common design in fact most current solution segregated the POS and POI completely anything that handles the actual credit card whether it's C&P, Track2 or NFC is a closed black box with the required PED/PTS/POI and P2PE certifications the merchant never sees what's going on they only can talk to the thing in bill the next card X and get a confirmation of the transaction that's it they don't see any of the card data they don't even see any card holder data unless they collect it in a side channel e.g. a loyalty program.
Now none of these certifications or standards is bullet proof but people have a very skewed vision of the PCI certification process likely due to bias of only having interacting with the PCI-DSS requirements for merchants and low levels to boot meaning they didn't had to do anything but to fill the SAQ themselves and be on their way.
There is a lot of reason why you can prefer a linked-list over an array, even with the hardware changing they are still a lot more efficient in some cases :
* In multi-threaded context insertion and deletion can be done lock-free which is not the case for arrays ;
* For intrusive list, insertion and deletion can't fail due to memory allocation ;
* If you do only insertion at the tail and removal at the head these operation need only a pointer change which is more efficient than an array ;
* Merging two list is only one pointer operation ;
* Intrusive list have better memory allocation properties ;
* ...
If you look at the usage of linked-list in the kernel you will see that they are used for reasons.
The problem is that, on new hardware, linked list should be used in less cases that in the past and some people have generalized this to linked-list should never be used. This is false, if you care about performances you should keep thinking and testing what is the best data-structure in different cases. If you don't care about performances, you should use an abstraction who implement what you need and don't car about the underlying data-structure.
> In multi-threaded context insertion and deletion can be done lock-free which is not the case for arrays
I just love when multithreaded code frees the element I currently iterate over in a different thread.
> For intrusive list, insertion and deletion can't fail due to memory allocation ;
As long as you store your elements on the stack or use static values you mean? Heap allocation happens at some point, you just move the location where it happens.
> If you do only insertion at the tail and removal at the head these operation need only a pointer change which is more efficient than an array
Use a circular buffer. Until the array is full you can just modify the start/end pointers.
Or just browse the article with a mobile user-agent. Big site like this cannot cut themselves from big market like iOS or Android, so there is always a non-flash version available.
