Explore
For Enterprise
Join for Free
Log In

예술 & 인문학
비즈니스
컴퓨터 공학
데이터 과학
정보 기술
건강
수학 및 논리
자기개발
물리 과학 및 공학
사회 과학
언어 학습
학위
수료증

Explore all of Coursera

검색
포 엔터프라이즈 (For Enterprise)
로그인
무료 회원 가입

While Loops

Loading...

Java Programming: Solving Problems with Software

듀크대학교

4.6(2,729개의 평가) | 120K명의 학생이 등록함

Object Oriented Programming in Java 전문 분야에서 4의 강좌 1

Learn to code in Java and improve your programming and problem-solving skills. You will learn to design algorithms as well as develop and debug programs. Using custom open-source classes, you will write programs that access and transform images, websites, and other types of data. At the end of the course you will build a program that determines the popularity of different baby names in the US over time by analyzing comma separated value (CSV) files. After completing this course you will be able to: 1. Edit, compile, and run a Java program; 2. Use conditionals and loops in a Java program; 3. Use Java API documentation in writing programs. 4. Debug a Java program using the scientific method; 5. Write a Java method to solve a specific problem; 6. Develop a set of test cases as part of developing a program; 7. Create a class with multiple methods that work together to solve a problem; and 8. Use divide-and-conquer design techniques for a program that uses multiple methods.

강의 계획서 보기

배우게 될 기술

Algorithms, Problem Solving, String (Computer Science), Java Programming

검토

4.6(2,729개의 평가)

5 stars
1,986 ratings
4 stars
540 ratings
3 stars
111 ratings
2 stars
33 ratings
1 star
59 ratings

DN

Aug 08, 2016

You need a little more experience in coding that just the first course, or try not to leave everything by the end of the week(as I did) to find what you need for the assignments. Great course !

JS

May 19, 2019

Really practical course content with great tutorials. The programming assignments are fun and challenging and deal with real world data and problems which makes the course all the more useful!

수업에서

Strings in Java

This module begins with a short presentation from Raluca Gordân, an assistant professor in Duke University’s Center for Genomic and Computational Biology, about an important problem genomics scientists encounter regularly: how to identify genes in a strand of DNA. To tackle this problem, you will need to understand strings: series of characters such as letters, digits, punctuation, etc. After learning about Java methods that work with strings, you will be able to find genes within a DNA string as well as tackle other string related problems, such as finding all of the links in a web page. By the end of this module, you will be able to: (1) Use important methods for the Java String class; (2) Use conditionals, for loops, and while loops appropriately in a Java program; (3) Find patterns in the data represented by strings to help develop the algorithm for your program; (4) Understand the importance of designing programs that keep different data processing steps separate; (5) Use the StorageResource iterable for this course to store some data for further processing; and (6) Rely on Java documentation to better understand how to use different Java packages and classes.

Introduction0:48

Conceptual Understanding4:01

While Loops9:30

While Loop Syntax and Semantics3:06

Coding While Loops6:45

Three Stop Codons5:03

Coding Three Stop Codons - Part I7:45

Coding Three Stop Codons - Part II4:35

Logical And / Or8:01

Coding And / Or6:52

Finding Multiple Genes5:16

Translating to Code8:00

강사:

Owen Astrachan
Professor of the Practice
Robert Duvall
Lecturer
Andrew D. Hilton
Associate Professor of the Practice
Susan H. Rodger
Professor of the Practice

스크립트

As you have been learning about strings you have been improving on your algorithm

to find genes in DNA.

However, lets take a moment to think about what your algorithm would do on this

string.

You will find the start codon ATG at index 0,

then it will find the stop codon, TAA at index 8.

It will then check if the distance between them, which is eight,

is a multiple of three.

Because eight is not a multiple of three,

your algorithm will conclude that this is not a valid gene.

Between the ATG and TAA there is one full codon,

ATC, and two-thirds of another code on, GC.

But if you were to keep looking past this TAA you

would find another TAA at index 15.

Now the distance between the ATG and

TAA is 15 which is a multiple of three, so this is a valid gene.

The first TAA that we found was not actually a codon, but

rather pieces of two adjacent codons, the T from GCT, and the AA from an AAT.

Your next improvement to the gene finding algorithm is to add this functionality,

to make the algorithm keep looking until it finds a stop codon that is

a multiple of three away from the start codon.

Having just worked that example let us now do step two of the seven step process and

write down what we just did.

The first thing we did was to find the ATG.

Then we found the first occurrence of TAA after the ATG

which was right here at index eight.

Then we checked that the distance between them was a multiple of three or not.

In this case, it was not.

So we found the next TAA after this first one.

The second one is right here at index15.

Then we checked if the distance between this TAA and

the start codon was a multiple of three.

It was, so that all of the sub string from 0 up to 18 was our answer.

In this particular set of steps,

we checked in two places to see if the distance was a multiple of three.

If this works in the general case,

you can just implement this algorithm with familiar if else statements.

However, do we always only need to check twice?

Let's look at a different DNA string.

With this DNA string we would need to check three times.

The first two TAAs are not a multiple of three away

from the start codon but the third one is.

Would checking three times be enough?

Could we have to check 4 times, 5, 10, 50 times?

This raises the question of how many times we have to check in general.

And the answer is that we cannot think of a particular number of times.

Even if you wrote 50 if else statements,

we could come up with a DNA string that has more than 50 TAAs that

are not a multiple of three away from the start codon before finding a valid one.

Instead we need to write our algorithm so

that it repeats the checking however many times it needs to.

As you have seen before, repetition in your algorithm will turn into

a loop when you translate the algorithm into code.

To express your algorithm with repetition, you will need to

make the repetitive steps the same and figure out what to loop over.

Previously you have seen four loops,

which iterate over the elements in some interval such as pixels in an image.

Now, you're going to learn about a new kind of loop known as a While Loop,

which lets you iterate as long as some condition holds.

Before we try to generalize these steps by finding repetition,

let's be a bit more precise about what we did.

We found the first ATG at index zero.

For the first TAA we started looking at index three and found it at index eight.

We checked if eight was a multiple of three, it wasn't.

So we started looking at index nine for

the second TAA and we found it at index 15.

We checked if 15 was a multiple of 3, it was, so everything between was our answer.

Now, let us take these steps and generalize them.

We looked for ATG here, why was that?

We always want to look for ATG because it is the start codon.

What about the fact that we found it at index zero?

We're not always going to find it at index zero,

however we are going to want to use that information, so let's give that a name.

When we turn this into code, what will be a variable that we will assign to this

in this line and then use later?

In particular, we'll call it StartIndex.

What about looking for TAA?

We will always want to look for TAA, since that is the stop codon.

Will we always start at index three?

Probably not.

Why did we start at index three here?

We started there because it was right after the start codon that we found.

In the general case, this would be startIndex + 3.

We won't always find it at index eight either, so let's give that a name too.

We'll call it currIndex.

Let's also be a bit more specific about the distance between them.

It is currIndex minus startIndex.

Which happens in both of these steps.

Next, you aren't always going to start looking from index nine, but

why do we start at nine here?

If you look back at where we work the problem and wrote down our steps,

we started at nine because the previous one started at eight.

In our generalized algorithm, we named the previous location currIndex,

so we can start from currIndex + 1.

We also should name the location where we found it.

Should we give it a new name such as nextIndex?

Or should we just update an existing name such as, currIndex?

In this case, we want to update currIndex since that represents

where we have found the most recent TAA.

If you did not realize this right away and gave it a different name,

you would realize it later on as you try to make the steps uniform so

that you can express the repetition.

Finally, we'll generalize the last step to just indicate that

the text between them is the text from start index to currIndex + 3.

Now these steps look repetitive.

The repetition maybe a bit hard to see since it only happens twice.

But if you wrote down the steps for strings with more TAAs that dont work

you would see that you do these steps over and over again.

To make this repetitive let's write it down like this.

Notice that steps four, five, and six are what we will repeat.

We've slightly adjusted the steps from before to reflect the choice we were

making in step four and the two possible outcomes in steps five, and six.

However, we have left the conditions under which we'll repeat these steps blank here.

How do we know when to stop repeating them?

Also what would you do after you stopped repeating this loop?

We would stop if we run out of TAAs.

If that happened currIndex would be minus 1, which you know from having learned that

you get minus 1 when you cannot find something in a string.

If you were to encounter this case,

it would mean that there is no valid gene in the string.

So you should give an answer of the empty string.

If you did not see this right off, what could you do to figure it out?

You should work more examples until you understand the pattern.

Now, your algorithm is generalized.

But you'll need to learn about while loops before you can translate this

into code, thank you.

Coursera 카탈로그 살펴보기

무료로 참여해 맞춤화된 추천, 업데이트 및 제안을 받아보세요.

Coursera는 세계 최고의 교육에 대한 보편적인 접근 기회를 제공하며, 최고의 대학 및 기관들과 제휴하여 온라인 강좌를 제공합니다.

© 2019 Coursera Inc. All rights reserved.

앱스토어에서 다운로드하기

구글 플레이에서 받기

Coursera
소개
리더십
직업
카탈로그
수료증
MasterTrack™ 수료증
학위
포 엔터프라이즈 (For Enterprise)
정부용

커뮤니티
Learners
Partners
Developers
Beta Testers
Translators

연결
블로그
Facebook
Linkedin
Twitter
Instagram
YouTube
기술 블로그

이상
조건
개인정보 보호
도움말
접근성
보도 자료
문의하기
디렉토리
계열사