I have no experience with Python coding and so on, so I need your help to create a plugin that goes to the website and reads Captcha for answers in-game to the clock

is that possible? If there are Python experts, I am very grateful. Waiting for your comments below thank you …

## nt.number Theory – Primes expand digit by digit while preserving the prime number

I looked at a primes table and saw the following:

If we decide $$7$$ Can we chain one digit to the left to form a new prime? Yes, concatenate $$1$$ receive $$17$$, Can we do that too? $$17$$? Yes, concatenate $$6$$ receive $$617$$, And with $$617$$? Yes, concatenate $$2$$ receive $$2617$$, Then we can shape ourselves $$62617$$, And I could not move on because table gives primes with the last entry $$104729$$,

Now some terminology. Call a prime $$a_1 … a_k$$ on Survivor of the order $$m$$ if it exists $$m$$ digits $$b_1, …, b_m$$ (all different from zero) so that the numbers pay $$b_1a_1 … a_k$$ and $$b_2b_1a_1..a_k$$ and and $$b_mb_ {m-1} … b_1a_1 … a_k$$ are all primes.

Call a prime $$a_1 … a_k$$ on Survivor of the order $$+ infty$$ if $$a_1 … a_k$$ is a Survivor of the order $$m$$ for each $$m in mathbb N$$,

I would like to know:

Is there a Survivor of the order $$+ infty$$?

(This question with exactly the same title and content was posted to MSE about an hour ago, and I think I should apologize for asking the same question here and there at such short intervals, but when I thought that someone would very quickly come up with an argument, with which the question would be decided, and that did not happen, I have decided to put it here too, so that this question also takes note here, hope you like it.)

## Digit Btc Immediate and fast payment 2019

I am not an administrator here!

QUOTE

digitbtc.com – this is your financial platform that allows you to make good money with minimal risk.
The platform is managed by experienced staff who have extensive experience and connections in this area. Our site meets all modern security standards, has licensed software and competent support staff. Our tariff plans are very flexible and can meet the needs of both beginners and experienced traders.
For partners with their structures we have a special surprise – this is a 3-step recommendation program.

All of our benefits are created to stimulate and promote our website, which gives our participants good returns.

Fast Plan 11.5% – 18% every hour for 9 hours
Plan Issued Amount ($) Hourly Profit (%) Plan 1 1.00 – 250.00 11.50 Plan 2$ 251.00 – $1000.00 13.00 Plan 3$ 1001.00 – $10000.00 14.00 Plan 4$ 10001.00 – $50000.00 16.00 Plan 5:$ 5,000.00 – $100,000.00$ 18.00

290% after 3 days
Plan amount spent ($) Profit (%) Plan 1 1.00 – 250.00 150.00 Plan 2$ 251.00 – $1000.00 170.00 Plan 3$ 1001.00 – $5000.00 200.00 Plan 4$ 10001.00 – $50000.00 240.00 Plan 5:$ 5,0001.00 – $100,000.00,$ 290.00

590% after 7 days
Plan amount spent ($) Profit (%) Plan 1 1.00 – 250.00 350.00 Plan 2$ 251.00 – $1000.00 400.00 Schedule$ 3 1001.00 – $10000.00 500.00 Plan 4$ 10001.00 – $50000.00 550.00 Plan 5 50001.00 USD – 100000.00 USD 590.00 USD 1100% after 14 days Plan amount spent ($) Profit (%)
Plan 1 1.00 – 250.00 700.00
Plan 2 $251.00 –$ 1000.00 800.00
Plan 3 $1001.00 –$ 5000.00 900.00
Plan 4 5001.00 USD – 10000.00 USD 1000.00 USD
Plan 5 $10001.00 –$ 100000.00 1100.00

2200% after 24 days
Plan amount spent ($) Profit (%) Plan 1 1,00 – 250,00 1400,00 Plan 2$ 251.00 – $1000.00 1600.00 Plan 3$ 1001.00 – $5000.00 1800.00 Plan 4$ 5001.00 – $10000.00 2000.00 Plan 5$ 10001.00 – $100000.00 2200.00 QUOTE SSL encryption DDoS Protection Licensed script Registrar NAMECHEAP INC Created on 11.06.2019 Expires on 2020-06-11 Updated on toget12-31 NS DNS1.NAMECHEAPHOSTING.COM DNS2.NAMECHEAPHOSTING.COM DNS1.NAMECHEAPHOSTING.COM DNS2.NAMECHEAPHOSTING.COM Accept: PM, Payeer, Bitcoin, …. Join here: https://digitbtc.com/ My deposit: QUOTE The amount of$ 120 has been deducted from your account.
Accounts: U4603107-> U20071003. Note: shopping cart payment.
Deposit money on digitbtc.com user hyiptank ..
Date: 08:50 16.06.19. Batch: 266994305.

## DIGIT BTC Immediate and fast payment 2019 – digitbtc.com – HYIPs

Quote

digitbtc.com – this is your financial platform that allows you to make good money with minimal risk.
The platform is managed by experienced staff who have extensive experience and connections in this area. Our site meets all modern security standards, has licensed software and competent support staff. Our tariff plans are very flexible and can meet the needs of both beginners and experienced traders.
For partners with their structures we have a special surprise – this is a 3-step recommendation program.

All of our benefits are created to stimulate and promote our website, which gives our participants good returns.

Quote

SSL encryption
DDoS Protection
Registrar NAMECHEAP INC
Created on 11.06.2019
Expires on 2020-06-11
Updated on toget12-31
NS DNS1.NAMECHEAPHOSTING.COM DNS2.NAMECHEAPHOSTING.COM
DNS1.NAMECHEAPHOSTING.COM DNS2.NAMECHEAPHOSTING.COM

Accept: PM, Payeer, Bitcoin, ….

Join here: https://digitbtc.com/

Quote

The amount of \$ 120 has been deducted from your account.
Accounts: U4603107-> U20071003. Note: shopping cart payment.
Deposit money on digitbtc.com user hyiptank ..
Date: 08:50 16.06.19. Batch: 266994305.

## Python – Verhoeff check digit algorithm

A recent question about credit card validation here at Code Review led me into a dark hole with check digit algorithms. I stopped at the Verhoeff algorithm and tried to implement it myself.

This resulted in the following code:

Class Verhoeff:
Calculate and check the check digits with the Verhoeff algorithm.

MULTIPLICATION_TABLE = (
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9),
(1, 2, 3, 4, 0, 6, 7, 8, 9, 5),
(2, 3, 4, 0, 1, 7, 8, 9, 5, 6),
(3, 4, 0, 1, 2, 8, 9, 5, 6, 7),
(4, 0, 1, 2, 3, 9, 5, 6, 7, 8),
(5, 9, 8, 7, 6, 0, 4, 3, 2, 1),
(6, 5, 9, 8, 7, 1, 0, 4, 3, 2),
(7, 6, 5, 9, 8, 2, 1, 0, 4, 3),
(8, 7, 6, 5, 9, 3, 2, 1, 0, 4),
(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
)

INVERSE_TABLE = (0, 4, 3, 2, 1, 5, 6, 7, 8, 9)

PERMUTATION_TABLE = (
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9),
(1, 5, 7, 6, 2, 8, 3, 0, 9, 4),
(5, 8, 0, 3, 7, 9, 6, 1, 4, 2),
(8, 9, 1, 6, 0, 4, 3, 5, 2, 7),
(9, 4, 5, 3, 1, 2, 6, 8, 7, 0),
(4, 2, 8, 6, 5, 7, 3, 9, 0, 1),
(2, 7, 9, 3, 8, 0, 6, 4, 1, 5),
(7, 0, 4, 6, 9, 1, 3, 2, 5, 8)
)

@classmethod
def compute (cls, input_: str) -> str:
Calculate the check digit with the Verhoeff algorithm.
check_digit = 0
for i digit in enumeration (inverse (input_), 1):
col_idx = cls.PERMUTATION_TABLE[i % 8][int(digit)]

check_digit = cls.MULTIPLICATION_TABLE[check_digit][col_idx]

return str (cls.INVERSE_TABLE[check_digit])

@classmethod
def validate (cls, input_: str) -> bool:
Check the check digit with the Verhoeff algorithm.
check_digit = 0
for i digit in enumeration (inverse (input_)):
col_idx = cls.PERMUTATION_TABLE[i % 8][int(digit)]

check_digit = cls.MULTIPLICATION_TABLE[check_digit][col_idx]

Return cls.INVERSE_TABLE[check_digit] == 0



I decided to implement it as a class with two class methods, as I intend to include other algorithms, and structuring the code in this way seemed reasonable to me.

Your feedback on the following aspects is of particular interest to me:

1. What do you think about the API? calculate (input_: str) -> str and validate (input_: str) -> bool reasonable and symmetrical, but I could also use something like picture calculate (input_: sequence[int]) -> int/validate (input_: Sequence[int], int) -> bool,
2. There seems to be a reasonable amount of code duplication between the two functions calculation/to confirmbut I could not really put my hand over how to define one in relation to the other.

In addition to the above class, I've decided to do some unit testing on the algorithm with pytest.

Import string
import itertools

import pytest

from check_sums import Luhn, Damm, Verhoeff

# Modifiers and utility functions to test the robustness of the check digit algorithm
DIGIT_REPLACEMENTS = {
digit: string.digits.replace (digit, "") for digit in string.digits
}

def single_digit_modifications (input_):
Generate all single-digit modifications of a numeric input sequence
for i digit in enumeration (input_):
to replace in DIGIT_REPLACEMENTS[digit]:
Yield Input_[:i] + replacement + input_[i+1:]

def transposition_modifications (input_):
"" "Pairwise transposition of all adjacent digits

The algorithm tries to make sure that the transpositions really change
Entrance. This is done to make sure that these permutations actually change that
Entrance."""
for i number in list (input_[:-1]):
if numeral! = Input_[i+1]:
Yield Input_[:i] + input_[i+1] + digit + input_[i+2:]

def flattening (iterable_of_iterables):
"" "Flatten a nesting level

Borrowed from
https://docs.python.org/3/library/itertools.html#itertools-recipes
"" "
return itertools.chain.from_iterable (iterable_of_iterables)

# Verhoeff algoritm related tests

# Test data from
# https://en.wikibooks.org/wiki/Algorithm_Implementation/Checksums/Verhoeff_Algorithm
VALID_VERHOEF_INPUTS = [
"2363", "758722", "123451", "1428570", "1234567890120",
"84736430954837284567892"
]

@pytest.mark.parametrize ("input_", VALID_VERHOEF_INPUTS)
def test_verhoeff_calculate_validate (input_):
Test Verhoeff.calculate / Verhoeff.validate with known valid entries
claim Verhoeff.calculate (input_[:-1]) == input_[-1]
and Verhoeff.validate (input_)

@pytest.mark.parametrize (
"Modified_input"
flatten (single_digit_modifications (i) for i in VALID_VERHOEF_INPUTS)
)
def test_verhoeff_single_digit_modifications (modified_input):
Test if single-digit changes can be detected
do not insure Verhoeff.validate (modified_input)

@pytest.mark.parametrize (
"Modified_input"
Flattening (Transposition_Modifications (i) for i in VALID_VERHOEF_INPUTS)
)
def test_verhoeff_transposition_modifications (modified_input):
Test if transposition changes can be detected
do not insure Verhoeff.validate (modified_input)



The tests cover known pre-calculated input and check digit values ​​as well as some of the basic error classes (single-digit errors, transpositions) that the checksum was designed to detect. I've decided to generate all the modified input in the test fixture to make it easier to see which of the modified inputs is causing the algorithm to fail. So far I have not found any.

## Arithmetic – Are these ways helpful for the complement implementation of a BCD digit for 9?

I have two options for adding 9 to the BCD number.

The first way I tried is as follows:

What I did is if we have 4-bit digit T as abcd:

1001 (~ 9) - abcd (in BCD) = 1001 + (2's complement of abcd) = 9's complement


the has chart implementation.

The next way is as follows:

in which I showed a truth table with a 4-bit point T (BCD abcd) as the input and a nine's complement of T as the output, I can also use the circuit with K-map.

My question is whether these paths are correct for nine supplements or not.

## Floating point – proof that a guard digit has limited the deduction error

I have read what every computer scientist should know about floating point arithmetic, which is extremely interesting. However, I have some difficulty understanding the proof of Theorem 9 (page 33).

First a pretty trivial question. If the formula $$(15)$$ say:
$$y – bar {y} lt ( beta – 1) ( beta ^ {- p} + dots + beta ^ {- p-k})$$
Should not it be? $$le$$ instead of $$lt$$or did I miss something?

More importantly, I do not understand why it says so if $$x- bar {y} lt 1$$, then $$delta = 0$$, How can there be no rounding error?

Then it means:
$$x – y ge 1.0 – 0. overbrace {0 dots 0} ^ k overbrace { rho dots rho} ^ k ; textrm {with} ; rho = beta – 1$$

Why is that? The difference can not be arbitrarily small or even $$0$$?

And overall, correct me if I'm wrong, but the guard digit just saves the day when the input floats $$x$$ and $$y$$ are the exact numbers we want to subtract. If they are the well-rounded result of another calculation, there can still be a catastrophic cancellation. The guard digit would only bring the calculated value into the correct range.

## Discrete Mathematics – Compute the least significant digit of a large number with the exponent

Thank you for your response to the Mathematics Stack Exchange!

But avoid

• Make statements based on opinions; secure them with references or personal experiences.

Use MathJax to format equations. Mathjax reference.

## Return the precision of the first non-zero digit in a number representing the measurement error representation

I want to return the precision of the first non-zero digit of a number. The motivation is that I can quickly build up my error notation, which is the parenthesized notation, eg.
$$x = 1,234$$ with associated error $$Delta x = 0.0015$$ I would represent the measurement as $$1.23 (2)$$, I want to automate this so I:

• Determine the accuracy of the error. Round up with the next digit. So in pseudo-code:

DeltaX = 0.0015
DeterminePrecissionValue[DeltaX] (* Would come back: 3 *)
NumberForm[Numb, {DeltaX, 3}]
NumberForm[Numb, {X, 3}]

• Based on the above result, I would round up the reading
the accuracy of the error result and then format accordingly.

## List Editing – integers with a specific digit sum

My goal is to create a list of integers that are below a certain value $$r$$ equal to their total $$k$$,

My code below works fine but is slow. I would like to see efficient versions.

f[r_,s_]: = Select[Range[r]total[IntegerDigits[#]]== s &]