Хороший простой алгоритм для генерации ожерелий в Схеме?
Я постараюсь сделать заказ в вашем коде. Выборка данных в методе рендеринга не очень хорошая идея, лучше использовать методы жизненного цикла, например componentDidMount Чтобы обработать ваш результат запроса, установите поле состояния и в вашем рендере прочитайте данные из этого поля. Итак:
export default class ApiProduct extends Component {
constructor(){
super();
this.state = {
productData: undefined;
};
}
async componentDidMount(){
await this.fetchProduct();
}
fetchProduct = () => {
fetch('https://drawtopic.in/projects/wordpress/wp- json/wc/v2/products?consumer_key=ck_044491712632ef889ec13c75daff5879a8291674&consumer_secret=cs_a8e16c732e1812017e15d278e1dce2765a88c49b',{
method:'GET',
})
.then((response) => response.json())
.then((res) =>{
this.setState({
productData: res
})
})
}
render() {
const {productData} = this.state;
console.log(productData);
return (
<View/> // add here your code to render data properly
)
}}
4 ответа
Алгоритм FKM для генерации ожерелий. Схема PLT. Не настолько горячий на производительности. Это возьмет что-либо в качестве алфавита и отображает внутренние числа на то, что Вы обеспечили. Кажется, корректен; никакие гарантии. Я был ленив при переводе циклов, таким образом, Вы получаете это странное соединение для циклов и выходите из продолжений.
(require srfi/43)
(define (gennecklaces n alphabet)
(let* ([necklaces '()]
[alphavec (list->vector alphabet)]
[convert-necklace
(lambda (vec)
(map (lambda (x) (vector-ref alphavec x)) (cdr (vector->list vec))))]
[helper
(lambda (n k)
(let ([a (make-vector (+ n 1) 0)]
[i n])
(set! necklaces (cons (convert-necklace a) necklaces))
(let/ec done
(for ([X (in-naturals)])
(vector-set! a i (add1 (vector-ref a i)))
(for ([j (in-range 1 (add1 (- n i)))])
(vector-set! a (+ j i)
(vector-ref a j)))
(when (= 0 (modulo n i))
(set! necklaces (cons (convert-necklace a) necklaces)))
(set! i n)
(let/ec done
(for ([X (in-naturals)])
(unless (= (vector-ref a i)
(- k 1))
(done))
(set! i (- i 1))))
(when (= i 0)
(done))))))])
(helper n (length alphabet))
necklaces))
Я сделал бы два процесса шага. Во-первых, найдите каждую комбинацию n элементов от алфавита. Затем для каждой комбинации выберите самое низкое значение и генерируйте все перестановки остающихся объектов.
Править: Вот некоторый код. Это предполагает, что входной список уже отсортирован и что это не содержит дубликатов.
(define (choose n l)
(let ((len (length l)))
(cond ((= n 0) '(()))
((> n len) '())
((= n len) (list l))
(else (append (map (lambda (x) (cons (car l) x))
(choose (- n 1) (cdr l)))
(choose n (cdr l)))))))
(define (filter pred l)
(cond ((null? l) '())
((pred (car l)) (cons (car l) (filter pred (cdr l))))
(else (filter pred (cdr l)))))
(define (permute l)
(cond ((null? l) '(()))
(else (apply append
(map (lambda (x)
(let ((rest (filter (lambda (y) (not (= x y))) l)))
(map (lambda (subperm) (cons x subperm))
(permute rest))))
l)))))
(define (necklaces n l)
(apply
append
(map
(lambda (combination)
(map (lambda (permutation)
(cons (car combination) permutation))
(permute (cdr combination))))
(choose n l))))
(display (choose 1 '(1 2 3 4 5))) (newline)
(display (choose 2 '(1 2 3 4 5))) (newline)
(display (permute '(1 2))) (newline)
(display (permute '(1 2 3))) (newline)
(display (necklaces 3 '(1 2 3 4))) (newline)
(display (necklaces 2 '(1 2 3 4))) (newline)
Пример: (1 2 3), и (1 3 2) ожерелья длины 3 от алфавита {1 2 3}.
Вы забыли (1 1 1) (1 1 2) (1 1 3) (1 2 2) (1 3 3) (2 2 2) (2 2 3) (2 3 3) (3 3 3). Ожерелья могут содержать дубликаты.
Если Вы только искали ожерелья длины N, оттянутый из алфавита размера N, которые не содержат дубликатов, то это довольно легко: будет (N-1)! ожерелья и каждое ожерелье будут иметь форму (1 :: perm) где perm любая перестановка {2.. N}. Например, ожерелья {1.. 4} был бы (1 2 3 4) (1 2 4 3) (1 3 2 4) (1 3 4 2) (1 4 2 3) (1 4 3 2). При расширении этого метода для контакта с ожерельями без дубликатов длины K <N оставляют как осуществление для читателя.
Но если Вы хотите найти реальные ожерелья, которые могут содержать дублирующиеся элементы, затем это не настолько просто.
Как первая идея, можно сделать очевидное, но неэффективный: ступают через все комбинации и проверку, если они - ожерелье, т.е. если они - лексически самое маленькое вращение элементов (формальное определение на p 5 в вышеупомянутой газете). Это было бы похоже на способ, которым Вы сделали предложение, но Вы выбросите все неожерелья, как только они сгенерированы.
Кроме этого, я думаю, что необходимо будет понять эту статью (http://citeseer.ist.psu.edu/old/wang90new.html):
T. Wang и C. Дикарь, "Новый алгоритм для генерации ожерелий", Отчет TR-90-20, Факультет информатики, Университет штата Северная Каролина (1990).
Это не слишком твердо, можно сломать его путем реализации tau и sigma функции, как описано и затем применение их в порядке, обрисованном в общих чертах в статье.