open pdf form itextsharp c# : Delete text from pdf file application Library utility azure .net windows visual studio Proceedings_ICDD20152-part1620

Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
coada[1, k + 1] = inou; 
coada[2, k + 1] = jnou; 
coada[3, k + 1] = valnoua; 
u++; 
void LEE() 
int k, gata=0, inou, jnou, valnoua,SMIN=0; 
p = u = 1; 
coada[1, 1] = locstartx; 
coada[2, 1] = locstarty; 
coada[3, 1] = 1; 
selectat[locstartx, locstarty] = 1; 
while (gata == 0) 
for (k = 0; k < 4; k++) 
inou = coada[1, p] + di[k]; 
jnou = coada[2, p] + dj[k]; 
valnoua = coada[3, p] + 1; 
if (inou >= 0 && inou < m && jnou < n && jnou >= 0) 
if (selectat[inou, jnou] == 0 && matr[inou, jnou]!=-1) 
insereaza(inou, jnou, valnoua); 
matr[inou, jnou].Text = (p).ToString(); 
selectat[inou, jnou] = 1; 
if (inou == locfinalx && jnou == locfinaly) 
SMIN = valnoua; 
gata = 1; 
p++; 
SMIN = SMIN - 1; 
drum(locfinalx, locfinaly, 1); 
for (int i = 1; i < SMIN; i++) 
matr[traseu[1, i], traseu[2, i]].Text = (SMIN - i).ToString(); 
matr[traseu[1, i], traseu[2, i]].BackColor = Color.Azure; 
Using this algorithm I encountered the following problem: I knew the minimum steps between 
the two points but I didn’t know the 
path, which I solved with the following algorithm:  
void drum(int i, int j, int ct) 
int k = 0; 
int inou, jnou; 
int x, y; 
int i2 = 0, j2 = 0; 
int minimul = 9999999; 
for (k = 0; k < 4 && movement==true; k++) // orthogonal movement 
inou = i + di[k]; 
jnou = j + dj[k]; 
if (inou >= 0 && jnou >= 0 && inou < m && jnou < n) 
if (matr[inou, jnou].Text != "" && matr[i, j].Text != "") 
20
Delete text from pdf file - delete, remove text from PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Allow C# developers to use mature APIs to delete and remove text content from PDF document
remove text from pdf; pdf editor delete text
Delete text from pdf file - VB.NET PDF delete text library: delete, remove text from PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Programming Guide to Delete Text from PDF File
how to delete text from pdf; how to delete text from pdf document
Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
x = Convert.ToInt32(matr[inou, jnou].Text); 
y = Convert.ToInt32(matr[i, j].Text); 
if (x < y) 
if (minimul > x) 
minimul = x; 
i2 = inou; 
traseu[1, ct] = inou; 
j2 = jnou; 
traseu[2, ct] = jnou; 
for (k = 0; k < 8 && movement==false; k++) // diagonal movement 
inou = i + did[k]; 
jnou = j + djd[k]; 
if (inou >= 0 && jnou >= 0 && inou < m && jnou < n) 
if (matr[inou, jnou].Text != "" && matr[i, j].Text != "") 
x = Convert.ToInt32(matr[inou, jnou].Text); 
y = Convert.ToInt32(matr[i, j].Text); 
if (x < y) 
if (minimul > x) 
minimul = x; 
i2 = inou; 
traseu[1, ct] = inou; 
j2 = jnou; 
traseu[2, ct] = jnou; 
ct++; 
if (ct < SMIN) 
drum(i2, j2, ct); 
else 
for (i = 0; i < m; i++) 
for (j = 0; j < n; j++) 
matr[i, j].Text = ""; 
What this does it goes from the destination point to the starting point following a certain rule. 
In Lee’s algorithm I am marking each ce
ll in the matrix with the current step which is symbolized 
by p. So the rule is that starting from the destination point the algorithm looks for neighbours with 
the smallest numbering inside the cell and moves to that one and continues on until the starting 
point. This can be seen in Fig. 11. After the path is found the cells are emptied and marked with 
their line and column. This happens fast so it is not noticeable by the user.  
21
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
C# File: Merge PDF; C# File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read: PDF Text Extract; C# Read: PDF
delete text from pdf acrobat; delete text pdf acrobat
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
using RasterEdge.XDoc.PDF; How to VB.NET: Delete a Single PDF Page from PDF File. This is a VB .NET example for how to delete a single page from a PDF document.
delete text in pdf file online; how to delete text in pdf preview
Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
 Conclusion 
The main difference between this application and all the others I could find is the fact that you 
can create your own matrix
, you’re not stuck with a predefined one.
It is also easy to follow because of the different colouring, which are explained in the in the 
last group box of the application. 
The variety of ways find the solution of a certain configuration gives the user the ability to 
have both an overview and a detailed vision of the execution. Also the possibility to have a step 
by step execution is the strong point of this application. 
Fig. 11: Path finding algorithm 
22
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
Demo Code: How to Delete a Single PDF Page from PDF File in C#.NET. Description: Delete specified page from the input PDF file. Parameters:
pdf editor online delete text; delete text from pdf online
C# PDF Text Extract Library: extract text content from PDF file in
Able to extract and get all and partial text content from PDF file. How to C#: Extract Text Content from PDF File. Add necessary references:
delete text pdf document; how to delete text in pdf using acrobat professional
Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
Future improvements would include some sort of animations and a possibility to create big 
sized matrixes without the application crashing or having any kind of delay. 
References 
[1] DUMITRIU-
LUPAN, Nușa, PINTEA, Rodica, NIȚĂ, Adrian, NIȚĂ Mioara, Introducere în 
programarea .Net Framework, Editat de BYBLOS SRL sub coordonarea Agora Media SA, pentru 
Microsoft România, 2008.
[2] 
VIȘINESCU, Radu, VIȘINESCU Violeta, Algoritmul lui Lee. Teorie și aplicații, Gazeta informatică 
nr.15/2, Cluj-Napoca, 2005. 
[3] SIMIAN, Dana, STOICA, Laura, Progra
mare, Comunicare, Imaginație, Design. Lucrările Conferinței 
Naționale de Informatică pentru Elevi, Ediția I, Sibiu, 2015.
Ladislau Andrasi 
Liceul Tehnologic „Școala Națională de Gaz” 
Mediaș
Matematică –
informatică
Mediaș, România
ladiladi85@gmail.com 
23
VB.NET PDF Text Extract Library: extract text content from PDF
Extract and get partial and all text content from PDF file. Extract highlighted text out of PDF document. Extract Text Content from PDF File in VB.NET.
remove text watermark from pdf; remove text from pdf reader
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
size, images size reducing can help to reduce PDF file size effectively will also take up too much space, glyph file unreferenced can Delete unimportant contents
delete text from pdf with acrobat; pdf text watermark remover
Fifth International Students Conference on Informatics 
Imagination, Creativity, Design, Development 
ICDD 2015, May 21-23 
Sibiu, Romania 
 
 
 
 
 
 
 
 
Designing and implementing a programming language 
interpreter using Haskell 
 
Barbu Paul - Gheorghe 
Teacher Coordinator: -
 
 
 
 
Abstract 
Nowadays programming languages are ubiquitous, it is important to understand how they are 
created and how can we improve them, thus this paper aims to present the steps taken to design a 
programming language and implement an interpreter for it. This paper is also motivated by the fact 
that  we  have  to  understand  the  tools  that  we  use  and,  as  programmers,  our  main  tool  is  the 
programming language and its corresponding interpreter or compiler. 
Introduction
 
Programming languages are the basis of any programmer’s work and not only. Everything that runs on 
 computer  or  a  smart  device  has  to  be  programmed  by  some  means.  Those  means  are  the 
programming  languages  that  allow  us  to  express  ideas  in  code,  instructions  that  machines  can 
understand and execute. Taking into account the rapid growth 
[1]
of internet-connected devices it is 
safe to assume that the demand for applications (both online and offline) is rising. Due to the constant 
need  for applications, it  is also safe to assume  that programming languages will  also  continue  to 
evolve, new ones will appear and old ones will get deprecated by others. Regardless of what will 
happen  to  particular  programming  languages,  the  ideas  and  the  concepts  surrounding  them  will 
continue to persist (one such example is the 
closure 
[2]
), thus it’s necessary for us to have a basic 
understanding for how they work and how can we improve them, in other words we need to get a grip 
for the basics. This paper aims to do this by looking at the design and implementation process of an 
interpreted  programming  language,  called  ePseudocode 
[3]
 by  providing  a  fully  functional 
programming language. This language is aimed both at beginner programmers, that are still learning, 
by  providing  an  easy  to  use  syntax  and  pseudo-code  appearance  (hence  the  name)  and  at  more 
experienced programmers by providing advanced features such as user defined data types, anonymous 
functions and closures. It is important to note from the start that all the keywords of the language are 
in  Romanian,  since  the  language  is  aimed  primarily  at  Romanian  students  willing  to  get  into 
programming. It’s also interesting to see running programs written on the computer as if they were on 
paper.
24
C# PDF File Split Library: Split, seperate PDF into multiple files
Application. Best and professional adobe PDF file splitting SDK for Visual Studio .NET. outputOps); Divide PDF File into Two Using C#.
delete text pdf file; pull text out of pdf
C# PDF File Compress Library: Compress reduce PDF size in C#.net
size, images size reducing can help to reduce PDF file size effectively will also take up too much space, glyph file unreferenced can Delete unimportant contents
how to edit and delete text in pdf file online; erase text from pdf
Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
Related work
 
Programming languages 
[4]
are quite diverse, in paradigm, syntax or just purpose.
 
There are a lot of research projects 
[5]
that aim to improve programming languages and this leads to 
more and more languages being developed, keeping this in mind, I will list here only languages that 
influenced me while designing ePseudocode.
 
2.1  Haskell 
[6] 
Haskell is a programming language developed in academia, used as research ground for functional 
programming,  but  also  used  in  industry 
[7]
due  to  its  characteristics,  which  include  first-class 
functions, laziness, purity and pattern matching, among others.
 
From Haskell, ePseudocode takes the first-class functions, which means that functions can be passed 
around freely as arguments to or returned from other functions. ePseudocode, unlike Haskell, does not 
completely embrace the functional paradigm and has a more permissive type system, which results in 
faster development times, but also more bugs that may show up at runtime, in contrast with catching 
them at compile time.
 
Also Haskell is the host language for ePseudocode, chosen for the ability to work with algebraic data 
types,  which  simplifies  the  representation  and  traversal  of  the  abstract  syntax  tree  of  the  guest 
language. The Parsec 
[8]
library was a great plus, too, making the parser look very natural, almost like 
reading English, suppose the sequence for parsing 
if-else
blocks:
 
reserved tIf <?> tIf
 
cond <- expr
 
reserved tThen
 
thenStmts <- many mainParser
 
reserved tElse
 
elseStmts <- many mainParser
 
reserved tEndIf
 
return $ CompleteIf cond thenStmts elseStmts
 
 
A snippet 
[9]
of ePsudocode showing the ability to use functions as first-class citizens of the language:
 
 
func applyToRange(a, b, step, f)
 
pt i=a; i<=b; i=step(i) executa
 
f(i)
 
sfpt 
sffunc 
func main()
 
applyToRange(1, 5, func(x) ret x+1 sffunc, func(x) scrie(x*2) sffunc)
 
sffunc 
 
Here, 
applyToRange
is being passed not only the  lower  and upper bounds (
a
and 
b
),  but also the 
function that should provide the next value for the counter, 
step
, and the function that uses the counter 
in the loop’s body, 
f
. The output will be: 
246810
(the 
scrie
built-in function just writes whatever it is 
passed to it as argument to the screen without appending spaces or newlines).
 
25
Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
2.2  C 
[10] 
The main influence on ePseudocode was the C programming language, because it is the main language 
used in romanian high schools it's the first one encountered by pupils, thus it's important to keep some 
familiarity between ePseudocode and C in order for the transition to be easy. 
The syntax, like C, is block oriented, with all the blocks surrounded by instructions that mark the 
beginning and the end of the block. 
Also the file handling functions in the standard library  are inspired by  their counterparts in the C 
standard library. 
Unlike C, ePseudocode is a higher level language, it doesn't allow the programmer direct access to 
memory, so there is no pointer data type and no functions like 
malloc
or 
free
. The reason behind this 
decision is that beginners do not have to worry about manual memory management. It is important to 
note that C is a compiled language, whereas ePseudocode is interpreted, so the speed of programs 
written in my programming language is not nearly as good as programs written in C, this is a known 
problem and there are various solutions to it 
[11]
, but ePsoudocode implements none, in order to keep 
the interpreter simple to understand.
 
2.3  Python 
[12] 
From Python ePseudocode inherits the type system, or more precisely the lack of one thereof. Python 
is a duck typed language and so is the language I developed. The lack of explicit types allows the 
student to concentrate on the actual algorithms and ideas behind programming. One feature of Python 
is also the fact that some operators have English names like “
and”
and “
or”
this is also continued in 
ePseudocode, but, as said earlier, the operator names are in Romanian (e.g.: 
si
and 
sau
). The Python 
language is an interpreted one, as is ePseudocode, this allowed for a short development time of the 
interpreter and a quick minimum viable product. 
 
The language
 
ePseudocode is an imperative, dynamic, high level, general purpose, turing complete programming 
language, with a very permissive type system. 
The entry point in a ePseudocode program is the 
main
function, if it's missing, that constitutes an error. 
As usual the main function may take no arguments or one argument (the argument list).
 
func main(argv)
 
firstArg = argv[0]
 
sffunc 
Functions may be used as closures and anonymous functions, a feature inherited from Haskell: 
func plusN(n)
 
// this is a closure, defined as an anonymous function 
// it will capture its environment, 
// and thus n will be defined inside its body 
ret func(x)
 
ret n + x
 
sffunc 
sffunc 
26
Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
At  the  language  level  it  is  important  to  note  that  ePseudocode,  unlike Haskell  and  Python,  only 
provides a small number of basic data types. Apart from integers and floats, the list is the main data 
type, they are different from Haskell lists because one can store elements of different types, e.g.: 
= {"foobar", 42, 3.14}
 
Strings are also lists  of characters, but for which some syntactic sugar exists allowing them to be 
delimited  by double  quotes,  one  can  also  use  escaping sequences  inside  strings  as  shown  in  the 
example code that implements Conway’s Game of Life 
[13]
.
 
A programmer may also define his own data types using structures: 
struct KeyVal
 
key = ""
 
val = ""
 
sfstruct 
In the snippet above the 
KeyVal
structure holds two fields, a key and a value, with the default values 
being the empty string. In the example below 
Q
is a list that holds elements of type 
KeyVal
,
the fields in 
the structure are accessed similarly to C, by using the dot operator:
 
func minNode(Q)
 
min = Q[0]
 
pt i=1; i<lung(Q); i=i+1 executa
 
daca Q[i].key < min.key atunci
 
min = Q[i]
 
sfdaca 
sfpt 
ret min 
sffunc 
 
As can be seen from the examples, variables need not be declared before they are used, a variable 
declaration and definition is done in the same place. 
 
Standard library and tools 
The standard library and the tools are what influence a programming language's adoption. Having this 
in mind I also developed a small standard library 
[14]
containing some utility functions along with the 
built-in ones like: 
scrie
citeste
deschide
inchide
int
float
ceiling 
[15] 
 
Apart from the standard library there also exists syntax highlighting for Notepad++ 
[16]
, proving that 
ePseudocode  could  be  used  exactly  as  are  other  well  known  programming  languages  as  well  as 
showing that tools may be developed in order to aid the programmer’s job of writing programs in this 
new language.
 
The interpreter itself may be considered a tool and it has two modes of operation. The first mode 
allows  the  programmer  to  execute  code  interactively  in  a  REPL 
[17]
if  invoked  simply  as 
“epseudocode” without arguments. This mode allows for quick experimentation, the user can use the 
full power of the language similarly to the REPL provided by Python or the one provided by GHC 
27
Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
[18]
. The GHC REPL doesn’t allow the programmer to define functions, but the ePseudocode REPL 
allows one to define functions provided that they are written on a single line.
 
The  second  mode  of  operation  can  be  used  to  run  a  full  ePseudocode  program.  By  running 
“epseudocode huffman.epc” in a command line the code in the “huffman.epc” file will be executed by 
the interpreter and its results will be written on the stdout or in some files, depending on what the 
program does. 
The interpreter 
The  interpreter  for ePseudocode is  written  in  Haskell,  a high  level,  pure functional programming 
language with one of the strongest type systems out there. One of the reasons Haskell was chosen is 
for its ability to define algebraic data types, which makes the representation of the abstract syntax tree 
trivial, the AST for a ePseudocode statement looks like this: 
 
data Stmt = TypeDef String [Stmt]
 
| Assign Expr Expr
 
| CompleteIf Expr [Stmt] [Stmt]
 
| SimpleIf Expr [Stmt]
 
| While Expr [Stmt]
 
| For (Maybe Stmt) (Maybe Expr) (Maybe Stmt) [Stmt]
 
| Ret Expr
 
| Break
 
| Continue
 
| E Expr
 
 
The  interpreter  is  implemented  in  a  modular  way  by  separating  the  concerns  as  is  done  in  any 
interpreted language.  
5.1  The lexer 
[19] 
The lexer defines the available keywords in the language as well as the possible identifier names, an 
identifier has to start with a letter or an underscore and may contain letters, underscores and numbers, 
it cannot match any built-in keywords. The comments are also defined by the lexer and are identical to 
C, with the added feature that they can be nested, some C compilers do not allow this.
 
5.2  The parser 
[20] 
In an usual setup, the parser is in charge of translating the token stream produced by the lexer into a 
parse tree. ePseudocode, because of the parser combinator library it uses, takes another approach: the 
parser is fed directly with the text source code and, using parts of the lexer, translates the source code 
directly  into  the  abstract  syntax  tree.  This  is  possible  because  the  syntax  of  the  language  is  not 
complex and at first it allowed great flexibility in designing the language. 
Both the lexing and the parsing parts are built on top of the Parsec Haskell library. 
5.3  The evaluator 
[21] 
The heart of the interpreter for ePseudocode is the evaluator, it handles the translation of the abstract 
syntax tree to Haskell code that is ultimately executed to get the desired results. 
It is written in a pure functional way, relying heavily on recursion, monads and monad transformers as 
is the case with the majority of big Haskell applications. Being implemented in a pure functional way 
has  both  advantages  and  disadvantages: the  bright  side  would  be  that  the  code  is  pretty  straight 
28
Fifth International Students Conference on Informatics 
ICDD 2015 
May 21-23, 2015, Sibiu, Romania 
forward to read and to modify, functions are composed together to form the interpreter, but on the 
down side, the speed is not so great since modifying nested lists implies recreating the whole nesting 
structure and applying the modifications at every level, which brings in not only speed limitations, but 
also space leaks 
[22]
, defects for which Haskell, due to its lazy nature, is famous. When this is done in 
a loop the speed issues start to appear. This effect can be seen in the example code that implements 
Conway’s Game of Life. Running a single iteration (two passes that check the rules of the game in a 
40x20 matrix) both in Python 
[23]
and in ePseudocode yields the results illustrated by the  Fig plot.
 
 
Of course this defect can be optimized away by using the 
Data.IORef
Haskell module and modifying 
the lists in place instead of taking the functional approach.
 
Although the performance is not great, the programmer productivity is enhanced by the high level 
nature and the clean syntax of the language. The line counts of the two example implementations are 
illustrated below: 
Fig. 1: Speed comparison
29
Documents you may be interested
Documents you may be interested