scholarly journals Analisis Perbandingan Efisiensi Algoritma Brute Force dan Divide and Conquer dalam Proses Pengurutan Angka

2020 ◽  
Vol 12 (1) ◽  
pp. 52-58
Author(s):  
Fenina Adline Twince Tobing ◽  
James Ronald Tambunan
Keyword(s):  
Divide And Conquer ◽  
Brute Force ◽  
Running Time ◽  
Merge Sort ◽  
Quick Sort

Abstrak— Perbandingan algoritma dibutuhkan untuk mengetahui tingkat efisiensi suatu algoritma. Penelitian ini membandingkan efisiensi dari dua strategi algoritma sort yang sudah ada yaitu brute force dan divide and conquer. Algoritma brute force yang akan diuji adalah bubble sort dan selection sort. Algoritma divide and conquer yang akan diuji adalah quick sort dan merge sort. Cara yang dilakuakn dalam penelitian ini adalah melakukan tes dengan data sebanyak 50 sampai 100000 untuk setiap algoritma. Tes dilakukan dengan menggunakan bahasa pemrograman JavaScript. Hasil dari penelitian ini adalah algoritma quick sort dengan strategi divide and conquer memiliki efisiensi yang baik  serta running time yang cepat dan algoritma bubble sort dengan strategi brute force memiliki efisiensi yang buruk serta running time yang lama. Kata Kunci – Efisiensi, algoritma, brute force, divide and conquer, bubble sort, selection sort, quick sort, merge sort

scholarly journals TreeMerge: a new method for improving the scalability of species tree estimation methods

2019 ◽  
Vol 35 (14) ◽  
pp. i417-i426 ◽  
Author(s):  
Erin K Molloy ◽  
Tandy Warnow
Keyword(s):  
Large Scale ◽  
Species Tree ◽  
New Method ◽  
Divide And Conquer ◽  
Supplementary Information ◽  
Estimation Methods ◽  
Running Time ◽  
Tree Estimation ◽  
Computationally Intensive ◽  
A Minor

Abstract Motivation At RECOMB-CG 2018, we presented NJMerge and showed that it could be used within a divide-and-conquer framework to scale computationally intensive methods for species tree estimation to larger datasets. However, NJMerge has two significant limitations: it can fail to return a tree and, when used within the proposed divide-and-conquer framework, has O(n5) running time for datasets with n species. Results Here we present a new method called ‘TreeMerge’ that improves on NJMerge in two ways: it is guaranteed to return a tree and it has dramatically faster running time within the same divide-and-conquer framework—only O(n2) time. We use a simulation study to evaluate TreeMerge in the context of multi-locus species tree estimation with two leading methods, ASTRAL-III and RAxML. We find that the divide-and-conquer framework using TreeMerge has a minor impact on species tree accuracy, dramatically reduces running time, and enables both ASTRAL-III and RAxML to complete on datasets (that they would otherwise fail on), when given 64 GB of memory and 48 h maximum running time. Thus, TreeMerge is a step toward a larger vision of enabling researchers with limited computational resources to perform large-scale species tree estimation, which we call Phylogenomics for All. Availability and implementation TreeMerge is publicly available on Github (http://github.com/ekmolloy/treemerge). Supplementary information Supplementary data are available at Bioinformatics online.

Analisis Kinerja Algoritma Quick Double Merge Sort Paralel Menggunakan openMP

2020 ◽  
Vol 11 (2) ◽  
pp. 95-102
Author(s):  
I Nyoman Aditya Yudiswara ◽  
Abba Suganda
Keyword(s):  
Parallel Algorithms ◽  
The Other ◽  
Sorting Algorithm ◽  
Data Parallelism ◽  
Parallel Sorting ◽  
Sequential Algorithms ◽  
Sorting Algorithms ◽  
Merge Sort ◽  
Sort Algorithm ◽  
Quick Sort

Processor technology currently tends to increase the number of cores more than increasing the clock speed. This development is very useful and becomes an opportunity to improve the performance of sequential algorithms that are only done by one core. This paper discusses the sorting algorithm that is executed in parallel by several logical CPUs or cores using the openMP library. This algorithm is named QDM Sort which is a combination of sequential quick sort algorithm and double merge algorithm. This study uses a data parallelism approach to design parallel algorithms from sequential algorithms. The data used in this study are the data that have not been sorted and also the data that has been sorted is integer type which is stored in advance in a file. The parameter measured to determine the performance of the QDM Sort algorithm is speedup. In a condition where a large amount of data is above 4096 and the number of threads in QDM Sort is the same as the number of logical CPUs, the QDM Sort algorithm has a better speedup compared to the other parallel sorting algorithms discussed in this study. For small amounts of data it is still better to use sequential sorting algorithm.

scholarly journals Perbandingan Algoritma Boyer-Moore dan Brute Force pada Pencarian Kamus Besar Bahasa Indonesia Berbasis Android

2021 ◽  
Vol 1 (2) ◽  
pp. 54-60
Author(s):  
Candra Irawan ◽  
Mudafiq Riyan Pratama
Keyword(s):  
String Matching ◽  
Search Process ◽  
Brute Force ◽  
Text Search ◽  
Matching Algorithm ◽  
Running Time ◽  
The Right ◽  
Bahasa Indonesia ◽  
Testing Criteria

String matching is an algorithm for matching a text to another text or also known as a text search. There are several algorithms that can be used for string matching, including the Boyer-Moore algorithm and the Brute Force algorithm. The Boyer-Moore algorithm is a string matching algorithm published by Robert S. Boyer and J. Strother Moore in 1977. This algorithm is considered the most efficient algorithm in general applications. The Boyer-Moore algorithm starts matching characters from the pattern on the right. While the Brute Force algorithm is an algorithm that matches a pattern with all text between 0 and n-m to find the existence of a pattern in the text. These two algorithms have different patterns in the search process. In this article, a comparative analysis of the performance of the Boyer-Moore and Brute Force algorithms is carried out in a case study of the search for the Big Indonesian Dictionary (KBBI) based on Android. The search process is carried out by searching based on words and word descriptions. The results of this study indicate that the criteria for running time, the Brute Force algorithm is faster than the Boyer-Moore algorithm with the total running time of the Brute Force algorithm is 168.3 ms in words, 6994.16 ms in word descriptions, while the Boyer-Moore algorithm for running time reached 304.7 ms on the word, 8654.77 ms on the word description. In the testing criteria based on related keywords, the two algorithms can display the same list of related keywords.

scholarly journals Efisiensi Algoritma dan Notasi O-Besar

2011 ◽  
Vol 2 (2) ◽  
pp. 849 ◽  
Author(s):  
Subandijo Subandijo
Keyword(s):  
Time Complexity ◽  
Space Complexity ◽  
Brute Force ◽  
Running Time ◽  
Complexity Function

Efficiency or the running time of an algorithm is usually calculated with time complexity or space complexity as a function of various inputs. It is common to estimate their complexity in the asymptotic sense, i.e., to estimate the complexity function for arbitrarily large input. Brute-force algorithm is the easiest way to calculate the performance of the algorithm. However, it is not recommended since it does not sufficiently explain the efficiency of the algorithm. Asymptotic estimaties are used because different implementations of the same algorithm may differ in efficiency. The big-O notation is used to generate the estimation. 

scholarly journals Exact Method for Generating Strategy-Solvable Sudoku Clues

Algorithms ◽  
2020 ◽  
Vol 13 (7) ◽  
pp. 171
Author(s):  
Kohei Nishikawa ◽  
Takahisa Toda
Keyword(s):  
Time Limit ◽  
Exact Method ◽  
Limit Set ◽  
Brute Force ◽  
Regular Pattern ◽  
Brute Force Search ◽  
Running Time ◽  
Minimum Number ◽  
Rigorous Framework

A Sudoku puzzle often has a regular pattern in the arrangement of initial digits and it is typically made solvable with known solving techniques called strategies. In this paper, we consider the problem of generating such Sudoku instances. We introduce a rigorous framework to discuss solvability for Sudoku instances with respect to strategies. This allows us to handle not only known strategies but also general strategies under a few reasonable assumptions. We propose an exact method for determining Sudoku clues for a given set of clue positions that is solvable with a given set of strategies. This is the first exact method except for a trivial brute-force search. Besides the clue generation, we present an application of our method to the problem of determining the minimum number of strategy-solvable Sudoku clues. We conduct experiments to evaluate our method, varying the position and the number of clues at random. Our method terminates within 1 min for many grids. However, as the number of clues gets closer to 20, the running time rapidly increases and exceeds the time limit set to 600 s. We also evaluate our method for several instances with 17 clue positions taken from known minimum Sudokus to see the efficiency for deciding unsolvability.

Polygon Area Decomposition for Multiple-Robot Workspace Division

1998 ◽  
Vol 08 (04) ◽  
pp. 437-466 ◽  
Author(s):  
Susan Hert ◽  
Vladimir Lumelsky
Keyword(s):  
Divide And Conquer ◽  
Covering Problem ◽  
Partition Problem ◽  
Decomposition Problem ◽  
Running Time ◽  
Convex Decomposition ◽  
Polygon Decomposition ◽  
Polygon Area ◽  
Multiple Robot ◽  
Sweep Line

A new polygon decomposition problem, the anchored area partition problem, which has applications to a multiple-robot terrain-covering problem is presented. This problem concerns dividing a given polygon P into n polygonal pieces, each of a specified area and each containing a certain point (site) on its boundary or in its interior. First the algorithm for the case when P is convex and contains no holes is presented. Then the generalized version that handles nonconvex and nonsimply connected polygons is presented. The algorithm uses sweep-line and divide-and-conquer techniques to construct the polygon partition. The input polygon P is assumed to have been divided into a set of p convex pieces (p = 1 when P is convex), which can be done in O(vP log log vP) time, where vP is the number of vertices of P and p = O(vP), using algorithms presented elsewhere in the literature. Assuming this convex decomposition, the running time of the algorithm presented here is O(pn2+vn), where v is the sum of the number of vertices of the convex pieces.

Study of Scheduling in Programming Languages of Multi-Core Processor

2018 ◽  
Vol 2 (2) ◽  
pp. 101-109
Author(s):  
Mina Hosseini-Rad ◽  
Majid Abdolrazzagh-Nezhad ◽  
Seyyed-Mohammad Javadi-Moghaddam
Keyword(s):  
Programming Languages ◽  
Programming Model ◽  
Parallel Mode ◽  
Merge Sort ◽  
Multi Core Processor ◽  
Quick Sort

Over the recent decades, the nature of multi-core processors caused changing the serial programming model to parallel mode. There are several programming languages for the parallel multi-core processors and processors with different architectures that these languages have faced programmers to challenges to achieve higher performance. In addition, different scheduling methods in the programming languages for the multi-core processors have the significant impact on the efficiency of the programming languages. Therefore, this article addresses the investigation of the conventional scheduling techniques in the programming languages of multi-core processors which allows the researcher to choose more suitable programing languages by comparing efficiency than application. Several languages such as Cilk++، OpenMP، TBB and PThread were studied, and their scheduling efficiency has been investigated by running Quick-Sort and Merge-Sort algorithms as well.

Sign in / Sign up

Export Citation Format

Share Document