[Powered by Google Translate] [Walkthrough - సమస్య సెట్ 4]
[Zamyla చాన్ - హార్వర్డ్ యూనివర్శిటీ]
[ఈ CS50 ఉంది. - CS50.TV]
అన్ని కుడి. హలో, ప్రతి ఒక్కరూ, మరియు Walkthrough 4 కు స్వాగతం.
>> నేడు మా pset ఫోరెన్సిక్స్ ఉంది.
ఫోరెన్సిక్స్ బిట్మ్యాప్ ఫైళ్లు వ్యవహరించే కలిగి ఒక నిజంగా సరదాగా pset ఉంది
ఒక నేరం ఎవరో తెలుసుకోడానికి.
అప్పుడు మేము కొన్ని బిట్మ్యాప్ ఫైళ్లు పరిమాణాన్ని చూడాలని
అప్పుడు మేము కూడా, పునరుద్ధరించు అనే నిజంగా సరదాగా భాగంగా వ్యవహరించే చూడాలని
దీనిలో మేము ప్రాథమికంగా ఒక మెమరీ కార్డ్ ఇచ్చాడు చేస్తున్నారు
దీనిలో ఎవరైనా అనుకోకుండా వారి ఫైళ్లను అన్ని తొలగించారు,
మరియు మేము ఆ ఫైళ్ళను తిరిగి అడిగితే.
>> మేము pset పొందడానికి ముందు మొదటి, నేను నిజంగా కేవలం ప్రతి ఒక్కరూ అభినందించేందుకు మీరు.
మేము ఈ కోర్సు యొక్క midpoint వద్ద చేయబోతున్నారు.
Quiz 0 మాకు వెనుక మరియు మేము సగం, కాబట్టి ముఖ్యంగా, pset4 వద్ద ఉన్నారు.
మీరు మీ psets, pset0 మరియు pset1 తిరిగి చూస్తే మేము చాలా దూరంగా వచ్చి
కాబట్టి, ఆ గురించి మీరే అభినందించేందుకు
మరియు మేము కొన్ని నిజంగా సరదాగా stuff పొందడానికి వెళుతున్న.
>> కాబట్టి ఈ pset కోసం మా పరికరాలపెట్టె, మళ్ళీ, బదులుగా సుడో yum-y నవీకరణ పరుగు,
మీరు పైన ఉపకరణం యొక్క 17.3 మరియు ఉన్నప్పుడు మేము update50 అమలు చేయగలదు ఉన్నారు.
కాబట్టి update50 అమలు చేయండి - ఇది కొన్ని తక్కువ అక్షరాలు, చాలా సులభం -
మీరు ఉపకరణం యొక్క తాజా వెర్షన్ వద్ద ఉన్నట్లు నిర్థారించడానికి.
మేము CS50 చెక్ ఉపయోగించడం ప్రారంభించడానికి ముఖ్యంగా ఇది update50 ముఖ్యం.
కాబట్టి మీరు అలా నిర్ధారించుకోండి.
>> ఈ pset కోసం విభాగాల అన్ని కోసం,
మేము ఫైల్ ఇన్పుట్లను మరియు ప్రతిఫలాన్ని వ్యవహరించే కావడం చేస్తున్నారు, ఫైలు I / O.
మేము శ్రేణితో వ్యవహరించే కార్యక్రమాలు చాలా పైగా వెళ్ళడం చూడాలని
ఫైళ్ళను మరియు వంటి వాటిని సూచించే,
కనుక మేము నిజంగా తెలిసిన మరియు సౌకర్యవంతమైన అని నిర్ధారించుకోవాలి
ఎలా ఫైళ్లను ఇన్పుట్ మరియు అవుట్పుట్ వ్యవహరిస్తుంది.
>> ఈ pset కోసం పంపిణీ కోడ్ లో copy.c గా పిలువబడే ఒక ఫైల్, ఉంది
మరియు ఆ మాకు నిజంగా ఉపయోగకరంగా అన్నారు మనం కనుగొనేందుకు వెళుతున్న యొక్క
మేము వదులుకోవడానికి వెళుతున్న ఎందుకంటే నిజానికి copy.c ఫైలు కాపీ
మరియు కొద్దిగా సమస్య సెట్ మొదటి 2 భాగాలు చేరుకోవాలి దానిని మార్చడం.
>> నేను ముందే చెప్పాను, కావున అప్పుడు, మేము బిట్ మ్యాప్ చిత్రాలన్నీ అలాగే JPEGs వ్యవహరించే ఉంటాయి.
కాబట్టి నిజంగా, ఆ ఫైళ్ళను నిర్వహిస్తారు ఎలా నిర్మాణం understanding
మేము నిజంగా structs లోకి 0 సె మరియు 1s అనువదించు ఎలా
మరియు మేము నిజంగా అర్థం మరియు అర్థం మరియు సవరించవచ్చు విషయాలు,
ఆ, నిజంగా ముఖ్యమైన ఉంటుంది
కాబట్టి JPEG మరియు బిట్మ్యాప్ ఫైళ్లు వెళ్లడానికి మరియు ఆ నిర్మాణం అవగాహన.
>> Pset4, సాధారణ గా, ప్రశ్నలు ఒక విభాగం మొదలవుతుంది.
ఆ ఫైలు I / O వ్యవహరించే మరియు మీరు ఆ అభిమానం పొందుతారు.
అప్పుడు పార్ట్ 1 మీరు ఒక Bitmap ఫైల్ ఇచ్చిన చేస్తున్న దీనిలో, హూడన్ఇట్ ఉంది
అన్ని పైగా ఎర్రని చుక్కలు వంటి రకమైన కనిపిస్తోంది.
మరియు తర్వాత ప్రధానంగా మేము చేయబోతున్నామని ఈ ఫైలు తీసుకొని కొద్దిగా ఇది సవరణ
మేము చదువుకోవచ్చు ఒక రూపాన్ని.
ముఖ్యంగా, ఒకసారి మేము, మేము ఒకే ఫైల్ ఉంటుంది, పూర్తి
తప్ప మేము అన్ని ఎర్రని చుక్కలు దాగి దాగి సందేశాన్ని చూడండి చేయగలరు.
అప్పుడు పునఃపరిమాణం ఫైలు ఇచ్చిన, ప్రోగ్రామ్
మరియు తర్వాత ఇది అందిస్తుంది ఫైలు యొక్క పేరు ఇచ్చిన తరువాత, అదే ఒక సంఖ్య ఇవ్వబడుతుంది
నిజానికి ఆ పూర్ణ సంఖ్య విలువ తేడాతో ఆ బిట్మ్యాప్ పరిమాణాన్ని కనిపిస్తుంది.
అప్పుడు చివరగా, మేము తిరిగి pset ఉన్నాయి.
మేము ఒక మెమరీ కార్డ్ ఇచ్చిన తరువాత అన్ని ఫోటోలు తిరిగి ఉంటాయి
అనుకోకుండా తొలగించబడ్డాయి ఆ,
మేము నేర్చుకోవచ్చు కానీ, నిజానికి తొలగించారు మరియు ఫైల్ నుండి తొలగించబడింది లేదు;
వారు ఫైల్ లో ఉన్న మనం చూస్తూ ఉంటాము కోల్పోయింది, కానీ మేము తిరిగి చూడాలని.
>> గ్రేట్. కాబట్టి మీరు ఉపయోగిస్తున్న మేము విధులను పూర్తి జాబితాను I / O ప్రత్యేకంగా, ఇవి ఫైల్ వెళ్లే.
మీరు ఇప్పటికే కొంత fopen యొక్క ప్రాథమికాలను, fread, మరియు fwrite, చూసిన
కానీ మేము కొన్ని ఫైల్ మరింత చూడండి చూడాలని I / అటువంటి fputc వంటి O విధులు,
దీనిలో మీరు ఒక సమయంలో ఒక పాత్ర వ్రాయండి
మీరు రకమైన ముందుకు మరియు వెనుకకు ఫైలు స్థానం సూచిక కదలిక యొక్క, fseek కు
మరియు తర్వాత కొన్ని. కానీ మేము pset సమయంలో bit ఆ లోకి తీసుకెళ్తుంది.
>> కాబట్టి మొదటి, కేవలం ఫైల్ పొందడానికి I / O మేము pset వెళ్ళాలని ముందు,
ఫైలు తెరవడానికి, ఉదాహరణకు, మీరు ఏమి ఉంటుంది నిజానికి ఫైల్ ఒక పాయింటర్ సెట్.
కాబట్టి మేము ఫైల్ * పాయింటర్ ఉంది.
నా infile చేస్తాడు ఎందుకంటే ఈ సందర్భంలో, నేను పాయింటర్ లో ఒక కాల్ చేస్తున్నాను.
కాబట్టి నేను ఫంక్షన్ fopen ఆపై ఫైల్ పేరు ఉపయోగించడానికి వెళుతున్న
మరియు నేను వెళుతున్నాను దీనిలో మోడ్ ఫైలు వ్యవహరించే విధంగా.
కాబట్టి చదవడానికి ఈ సందర్భంలో "r", రచన కోసం "W", మరియు అప్పుడు అనుమతిస్తూ కోసం "ఒక" లేదు.
ఉదాహరణకు, మీరు ఒక infile వ్యవహరించే చేస్తున్నారు
మరియు మీరు చేయాలనుకుంటున్నారా అన్ని, అక్కడ నిల్వ బిట్స్ మరియు బైట్లు చదవబడుతుంది
అప్పుడు మీరు బహుశా మీ మోడ్ వంటి "r" ఉపయోగించాలనుకుంటున్న చూడాలని.
మీరు నిజంగా వ్రాయడానికి ఉంటుంది, ఒక విధమైన కొత్త ఫైల్ తయారు,
అప్పుడు మనం చేయబోతున్నామని మేము కొత్త ఫైల్ను తెరవడం చూడాలని ఉంది
మరియు వ్రాయడానికి "W" మోడ్ ఉపయోగించండి.
>> కాబట్టి మీరు నిజంగా ఫైల్ గా చదువుతున్న సమయంలో, నిర్మాణం కింది విధంగా ఉంటుంది.
మొదటి మీరు మీరు చదువుతున్న ఆ బైట్లు కలిగిన struct కు పాయింటర్ ఉన్నాయి.
తద్వారా మీరు చదువుతున్న ఆ బైట్లు ముగింపు నగర చేస్తాడు.
అప్పుడు మీరు పరిమాణాన్ని సూచించదు చూడాలని, ఇష్టం ప్రధానంగా ఎన్ని బైట్లు
మీ ప్రోగ్రామ్ ఫైల్ కు చదవడానికి కలిగి, పరిమాణం ప్రధానంగా ఒక మూలకం ఉంది
మరియు మీరు చదవాలనుకుంటున్న ఎన్ని అంశాలు తెలుపుటకు వెళుతున్న.
మరియు తర్వాత చివరిగా, మీరు, మీ నుండి చదువుతున్న పేరు తెలుసుకోవలసి ఉంటుంది
కాబట్టి మీ పాయింటర్ చేస్తాడు.
Fread కూడా fwrite చాలా పోలి ఉంటుంది ఎందుకంటే నేను, ఈ రంగులతో
మీరు కుడి క్రమంలో ఉపయోగించే నిర్ధారించుకోవాలి తప్ప,
మీరు నిజంగా వ్రాయడం లేదా కుడి ఫైలు నుండి చదువుతున్న నిర్ధారించుకోండి.
>> కాబట్టి అప్పుడు ముందు, మేము మూలకం యొక్క పరిమాణం అలాగే మూలకాల సంఖ్య ఉంటే,
అప్పుడు మేము ఇక్కడ కొద్దిగా చుట్టూ ప్లే చేసుకోవచ్చు.
నేను కుక్క struct కలిగి మరియు అందువల్ల నేను ఒక సమయంలో రెండు కుక్కలు చదవండి అనుకుందాం.
నేను చేయగలిగే మూలకం యొక్క పరిమాణం చెప్పాలి ఒక కుక్క పరిమాణంలో ఉంటుంది అన్నారు
మరియు నేను వాస్తవానికి రెండు చదవండి వెళుతున్న.
ప్రత్యామ్నాయంగా, నేను కాలేదు నేను ఒక మూలకం చదవండి వెళుతున్న చెప్పాలి
మరియు ఒక మూలకం రెండు కుక్కలు యొక్క పరిమాణం మాత్రం ఆ.
కాబట్టి ఆ అనురూప ఎలా మీరు పరిమాణం మరియు సంఖ్యలో చుట్టూ ఆట రకం చెయ్యవచ్చు
మీకు మరింత స్పష్టమైన దాని బట్టి.
>> అన్ని కుడి. కాబట్టి ఇప్పుడు మేము రచన ఫైళ్ళను ను.
మీరు నుండి చదువుతున్న పేరు మీరు ఒక ఫైల్ను వ్రాయడానికి ఉంటుంది, మొదటి వాదన నిజానికి ఉంది.
కాబట్టి, మీరు ఫైల్లోకి రాయడానికి వెళ్తున్నారు ప్రాథమికంగా డేటా యొక్క
తరువాత కూడా అవుట్ పాయింటర్ ఇది.
కాబట్టి మీరు pset వ్యవహరించే చేసినప్పుడు, మీరు అయోమయం పొందలేము నిర్ధారించుకోండి.
బహుశా పక్క నిర్వచనాలు వైపు ఉన్నాయి.
మీరు, ఉదాహరణకు, మనిషి టైప్ చేయడం ద్వారా మాన్యువల్లో నిర్వచనాలు పుల్ అప్ ఆపై fwrite చేయవచ్చు
టెర్మినల్ లో, లేదా మీరు ఈ స్లయిడ్ తిరిగి సూచించవచ్చు
మరియు మీరు సరైన ఉపయోగించే నిర్ధారించుకోండి.
మరలా, fwrite కోసం, మీరు ఒక ఫైల్ ఉన్నప్పుడు మీరు లోకి రాయడానికి కావలసిన
చివరి వాదన చేస్తాడు మరియు ఆ ఫైల్కు ఒక పాయింటర్ చేస్తాడు.
కాబట్టి ఆ, మేము ఒక సమయంలో బహుశా అనేక బైట్లు రాయడం వ్యవహరించే ఎలా
కానీ మీరు కేవలం ఒక్క పాత్ర లో రాయడానికి అనుకుందాం.
మేము ఈ ఉదాహరణ తర్వాత చూస్తారు వంటి, బిట్ మ్యాప్ చిత్రాలన్నీ లో మేము ఆ ఉపయోగించాలి.
మేము fputc ఉపయోగించవచ్చు ఉన్నప్పుడు ఆ, ముఖ్యంగా కేవలం chr, ఒక సమయంలో ఒక పాత్ర ఉంచడం
అక్కడ ఫైలు పాయింటర్ వలె, మరియు ఆ యొక్క మా అవ్ట్ పాయింటర్.
కాబట్టి అప్పుడు మేము, కోరుకుంటారు లేదా ఒక ఫైల్ లో వ్రాయడానికి చేసినప్పుడు
ఫైలు మేము ఎక్కడ పర్యవేక్షించడం ఉంది.
కనుక ఇది కర్సర్, ఫైలు స్థానం సూచిక ఒక విధమైన ఉంది.
మరియు, కాబట్టి మేము వ్రాయండి చేసినప్పుడు లేదా ఒక ఫైల్ లోకి మళ్లీ చదవండి
అది ఎక్కడ ఫైల్ వాస్తవానికి, గుర్తు
మరియు కనుక ఇది కర్సర్ ఎక్కడ నుండి కొనసాగుతుంది.
మీరు ఈ ఏదో ఒకటి చేయడానికి కొంత చదివిన, చెప్పడానికి, ప్రయోజనకరంగా ఉంటుంది
తరువాత, కింది మొత్తం లో చదవండి
కానీ కొన్ని సార్లు మనం కొంత సూచన విలువ నుండి ప్రారంభం తిరిగి లేదా వాస్తవానికి వెళ్ళి అనుకోవచ్చు.
కాబట్టి అప్పుడు fseek ఫంక్షన్, ఏ అది ఉంది మాకు ఒక నిర్దిష్ట ఫైల్ లో కర్సరును మరల్చటానికి అనుమతిస్తుంది
బైట్లు కొంత సంఖ్య.
మరియు తర్వాత మనం లేదు సూచన విలువ ఉన్న తెలియచేస్తాయి.
కాబట్టి గాని అది, కర్సర్ ప్రస్తుతం ఎక్కడ నుండి ముందుకు లేదా వెనకకు కదులుతుంది
లేదా మేము కేవలం ఫైల్ ప్రారంభంలో నుండి కదలాలని పేర్కొనవచ్చు
లేదా ఫైల్ ముగింపు నుండి.
మరియు మీరు, మొత్తం ప్రతికూల లేదా విలువలను లో తరలిస్తారు
మరియు ఆ రకమైన గాని ముందుకు లేదా వెనుకకు కర్సరును మరల్చటానికి కనిపిస్తుంది.
>> మేము ఇతర psets పొందడానికి ముందు, ఫైలు ఏ ప్రశ్నలు I / O?
సరే. మేము మరిన్ని ఉదాహరణలు పొందడానికి వంటి, ప్రశ్నలకు నాకు ఆపడానికి సంకోచించకండి.
>> కాబట్టి హూడన్ఇట్ లో, మీరు స్లయిడ్ ఈ Red ఒక సమానమైన Bitmap ఫైల్ అప్పగించారు చేస్తున్నారు,
మరియు ఈ కనిపిస్తోంది - ఎరుపు చుక్కలు బంచ్ - మరియు మీరు నిజంగా వ్రాసిన ఏమి లేదు.
మీరు ఓర కంటితో చూచు, మీరు మధ్య లోపల కొంచెం నీలి రంగు చూడండి చేయవచ్చు.
టెక్స్ట్ నిల్వ ముఖ్యంగా, ఆ.
అక్కడ జరిగిన ఒక హత్య, మరియు మేము అది చేసిన కనుగొనేందుకు అవసరం.
అలా చేయడానికి, మేము ఒక రీడబుల్ ఫార్మాట్ ఈ చిత్రం మార్చేందుకు రకం అవసరం.
మీరు అబ్బాయిలు ఎప్పుడూ ఈ ఎదుర్కొంది ఉంటే, కొన్నిసార్లు తక్కువ కిట్లు ఉంటాయి
మీరు ఒక Red సినిమా ఒక భూతద్దం ఉంటుంది. ఎవరైనా? అవును.
కాబట్టి మీరు ఈ చేతి ఏదో ఉంటుంది, మీరు ఒక భూతద్దం ఉంటుంది
దాని పై Red సినిమా, మీరు, చిత్రం పైగా ఉంచుతాడు
మరియు మీరు సందేశాన్ని అందులో దాగి చూడండి చేయగలదు.
మేము Red చిత్రం భూతద్దం లేదు, కాబట్టి మేము బదులుగా రకం మా స్వంత సృష్టించడానికి యొక్క చూడాలని
ఈ pset లో.
కాబట్టి యూజర్, అప్పుడు ఇన్పుట్ హూడన్ఇట్, క్లూ అన్నారు. Bmp,
ఎరుపు బిందువు సందేశాన్ని అని infile, కాబట్టి ఆ
మరియు తర్వాత వారు verdict.bmp మా outfile ఉండబోతుంది చెబుతున్న దాన్ని.
కనుక ఇది క్లూ కూడా ఇటువంటి ఒక కొత్త బిట్మ్యాప్ చిత్రం సృష్టించడానికి జరగబోతోంది
ఒక రీడబుల్ ఫార్మాట్ తప్ప అక్కడ రహస్య సందేశాన్ని చూడవచ్చు.
>> మేము, కొన్ని రకాల బిట్ మ్యాప్ చిత్రాలన్నీ సంకలనం మరియు మానిప్యులేట్ వ్యవహరించే కావడం ఉన్నందున
మేము ఈ బిట్మ్యాప్ ఫైళ్లు నిర్మాణాన్ని లో డైవ్ రకం చూడాలని.
మేము ఉపన్యాసంలో ఈ కొద్దిగా మీద వెళ్ళారు, కానీ కొన్ని చాలా వాటిని లోకి చూద్దాం యొక్క.
బిట్ మ్యాప్ చిత్రాలన్నీ ముఖ్యంగా బైట్లు కేవలం ఒక అమరిక ఉంటాయి
మేము పేర్కొన్న పేరు ఇది బైట్లు అర్థం.
ఇక్కడ బిట్మ్యాప్ చిత్రం యొక్క పటం వంటి రకమైన ఉంది
అది కొన్ని శీర్షిక ఫైళ్లు మొదలవుతుంది చెప్పి, అక్కడ కొంత సమాచారం మొదలవుతుంది.
మీరు గురించి బైట్ సంఖ్య 14 వద్ద పరిమాణం బిట్మ్యాప్ చిత్రం సూచించింది అని చూడండి
మరియు అది న కొనసాగుతుంది.
కానీ మాకు ఇక్కడ ఆసక్తి బైట్ సంఖ్య 54 చుట్టూ ప్రారంభిస్తోంది.
ఈ RGB ట్రిపుల్స్ ఉన్నాయి.
ఏమి జరగబోతోంది ఏ నిజమైన పిక్సెళ్ళు, రంగు విలువలను కలిగి ఉంది.
హెడర్ లో ఆ పైన అంతా కొన్ని సమాచారం
చిత్రం, చిత్రం యొక్క వెడల్పు మరియు ఎత్తు పరిమాణం సమానం.
మేము తర్వాత padding వెళ్ళాలని, మేము చూస్తారు ఎందుకు చిత్రం యొక్క పరిమాణం
వెడల్పు లేదా ఎత్తు కంటే భిన్నంగా ఉండవచ్చు.
కాబట్టి ఈ ప్రాతినిధ్యం - ఈ బిట్మ్యాప్ చిత్రాల బైట్లు యొక్క క్రమాలను ఉంటాయి -
సరే చెప్పాలి మేము ఏమి చేయగలరో, నాకు గుర్తు వెళుతున్న ఆ సూచిక 14 వద్ద,
మేము ఈ సులభంగా చేయబోతున్నామని ఏ బదులుగా పరిమాణం ఉదాహరణకు, ఇక్కడ, కానీ
ఒక struct లో టూకీగా చెప్పు ఉంది.
కాబట్టి మేము మా చేసిన రెండు structs, ఒక BITMAPFILEHEADER కలిగి
మరియు ఒక BITMAPINFOHEADER,
అందువలన ఆ ఫైల్ను కు చదవండి చేసినప్పుడు, డిఫాల్ట్గా ఇది క్రమంలో వెళ్ళడం వెళుతున్న
అందువలన క్రమంలో ఇది biWidth మరియు biSize వంటి వేరియబుల్స్ గా పూరించడానికి జరగబోతోంది.
మరియు తర్వాత చివరకు, ప్రతి పిక్సెల్ మూడు బైట్లు ప్రాతినిధ్యం వహిస్తుంది.
మొదటి ఒక పిక్సెల్ లో నీలం మొత్తం, రెండవ, ఆకుపచ్చ మొత్తం
చివరకు, 0 ముఖ్యంగా ఏ నీలం లేదా సంఖ్య ఆకుపచ్చ ఉన్న ఎరుపు, మొత్తం లేదా సంఖ్య ఎరుపు
ఆపై ff గరిష్ట విలువ.
ఈ హెక్సాడెసిమల్ విలువలు.
మేము ff0000 ఉంటే కాబట్టి అప్పుడు, ఆ నీలం గరిష్ట మొత్తం అనుగుణంగా
మరియు, ఆకుపచ్చ మరియు ఎరుపు, కాబట్టి ఆ మాకు ఒక నీలం పిక్సెల్ ఇస్తుంది ఏ.
మేము అన్ని కోణాల్లో ff యొక్క అన్ని ఉంటే అప్పుడు, ఆ మేము తెల్ల పిక్సెల్ ఉండవు.
మేము RGB చెప్పినప్పుడు మీరు ఇది వ్యతిరేక యొక్క రకం. ఇది వాస్తవానికి BGR జరగబోతోంది.
>> మేము అసలైన బిట్మ్యాప్ చిత్రం యొక్క ఒక ఉదాహరణ పరిశీలిస్తాము చేస్తే - నా ఇక్కడ ఒక పుల్ అప్ తెలియజేయండి.
ఇది ఒక చిన్న చిన్న యొక్క.
నేను జూమ్ వెబ్, మరియు మేము అది pixelated చూడండి చేయవచ్చు. ఇది రంగు బ్లాక్లు కనిపిస్తోంది.
అప్పుడు మీరు వైట్ బ్లాక్స్ మరియు ఎరుపు బ్లాక్స్ ఉన్నాయి.
మీరు మైక్రోసాఫ్ట్ పెయింట్ లో ప్లే, ఉదాహరణకు, మీరు అలాంటిదే చేస్తాయి
ద్వారా ప్రాథమికంగా ఒక నిర్దిష్ట క్రమంలో కొన్ని చతురస్రాలు పెయింటింగ్.
కాబట్టి అప్పుడు బిట్మ్యాప్ లో ఏ మాట కింది విధంగా ఉంది.
ఇక్కడ మేము అన్ని 6 F యొక్క ఉంటాయి, మొదటి వైట్ పిక్సెళ్ళు కలిగి, మరియు అప్పుడు మేము Red పిక్సెళ్ళు కలిగి
0000ff ద్వారా సూచించింది.
కాబట్టి మనం ఆ బైట్లు క్రమంలో బిట్మ్యాప్ చిత్రం చూడండి అన్నారు సూచిస్తుంది.
కాబట్టి నేను ఇక్కడ చేశాను అన్ని బైట్లు అవుట్ రాస్తారు మరియు ఎరుపు లో రంగు
మీరు రకమైన చూడండి తద్వారా, ఆ రకమైన ఒక స్మైలీ ముఖం సూచిస్తుంది ఎలా మీరు ఓర కంటితో చూచు కొద్దిగా, ఉంటే.
>> బిట్మ్యాప్ చిత్రాల పని నేను అని విధంగా ఒక గ్రిడ్ వంటి ప్రధానంగా ఇది ఊహ.
కాబట్టి అప్రమేయంగా, గ్రిడ్ యొక్క ప్రతి వరుస 4 బైట్లు ఒక బహుళ ఉండాలి.
మేము ఒక బిట్మ్యాప్ చిత్రం చూడండి, మీరు ప్రతి విలువ పూరించి చేస్తున్నారు.
ఉదాహరణకు, మీరు, ఇక్కడ, ఇక్కడ, ఇక్కడ ఒక నీలం ఆకుపచ్చ ఎరుపు కలిగి ఉండవచ్చు
కానీ మీరు చిత్రం నాలుగు బైట్లు ఒక బహుళ తో నిండి ఉంటుంది నిర్ధారించుకోండి ఉంటుంది.
నేను మూడు బ్లాక్స్ వ్యాప్తంగా నా చిత్రం కావాలా కాబట్టి, నేను ఒక ఖాళీ విలువ ఉంచాలి చేస్తుంది
చివరి లో నాలుగు ఒక బహుళ చేస్తుంది.
కాబట్టి అప్పుడు మనం padding కాల్ చేస్తున్నారు, ఇది ఏదో లో పేర్కొన్నారు.
నేను అక్కడ ఒక x తో సూచిస్తున్నాయి వెళుతున్న.
ఇప్పుడు మేము ఉదాహరణకు, 7 పిక్సెళ్ళు దీర్ఘ ఉన్న ఒక చిత్రం అనుకుందాం.
మేము 1, 2, 3, 4, 5, 6, 7, కలిగి
మరియు ఆ అన్ని రంగు తో నిండి ఉంటుంది.
బిట్మ్యాప్ చిత్రాల పని విధంగా మేము ఒక 8 అవసరం ఉంది.
ప్రస్తుతం మేము 1, 2, 3, 4, 5, 6, 7 ఉంటాయి.
మేము సరిగ్గా చదవడానికి బిట్మ్యాప్ చిత్రం కోసం 8 ఖాళీలను అవసరం.
కాబట్టి అప్పుడు మేము వాటిని padding కేవలం ఒక బిట్ లో చేర్చండి ఉంది
వెడల్పులను అన్ని ఏకరీతి అని నిర్ధారించడానికి
మరియు వెడల్పులను అన్ని 4 ఒక బహుళ అని.
కాబట్టి నేను గతంలో, ఒక x లేదా ఒక squiggly లైన్ వంటి పాడింగ్, సూచించిన
కానీ వాస్తవ బిట్మ్యాప్ చిత్రాల లో padding ఒక హెక్సాడెసిమల్ 0 ద్వారా తెలిసింది.
కాబట్టి ఆ ఒకే ఒక పాత్ర 0 ఉంటుంది.
ఏ ప్రయోజనం అందించడం ఉండవచ్చు xxd ఆదేశం ఉంది.
వాట్ అది నేను స్మైలీ తో ముందు ఏమి పోలి, వాస్తవానికి మీరు చూపిస్తుంది లాగా ఉంటుంది
నిజానికి ప్రతి రంగు పిక్సెల్ కోసం అంటే ఏమిటో ముద్రించిన ఉన్నప్పుడు
మీరు కింది ఆదేశాలను తో xxd అమలు చేసినప్పుడు మరియు తరువాత, అది రంగులతో
అప్పుడు నిజంగా రంగులు ఆ పిక్సెళ్ళు కోసం ఏమిటో ముద్రిస్తుంది.
మీరు ఏమి కలిగి-s 54 ఇష్టం, సూచిస్తున్నాయి ఇక్కడ పైగా ఉంది
నేను 54TH బైట్ వద్ద మొదలు వెళుతున్న చెప్పారు
మేము బిట్ మ్యాప్ చిత్రాలన్నీ యొక్క చిహ్నం తిరిగి చూస్తే ఆ ముందు ఎందుకంటే, గుర్తు
ఆ వంటి శీర్షిక సమాచారం మరియు విషయాలు అన్ని ఆ.
కానీ మాకు శ్రద్ధ రంగు సూచించే అసలు పిక్సెల్స్.
కాబట్టి,-S 54 ఆ జెండా లో జోడించడం ద్వారా, అప్పుడు మేము రంగు విలువలు చూడగలరు ఉన్నారు.
మరియు ఆ వంటి క్లిష్టమైన జెండాలు మరియు విషయాల గురించి ఆందోళన చెందకండి.
సమస్య సెట్ స్పెక్, మీరు పిక్సెళ్ళు ప్రదర్శించడానికి xxd ఎలా ఉపయోగించాలో న ఆదేశాలు ఉంటుంది.
మీరు ఇక్కడ చూడండి అయితే, అది ఒక రకమైన ఆకుపచ్చ బాక్స్, ఈ చిన్న విషయం కనిపిస్తోంది.
నిజానికి ఏ నీలం, ఆకుపచ్చ చాలా, మరియు ఎరుపు ఇలా 00ff00 రంగులతో చేసిన.
కాబట్టి ఆ ఆకుపచ్చ సూచించదు.
మీరు ఇక్కడ చూడండి, మేము ఒక ఆకుపచ్చ దీర్ఘ చతురస్రం చూడండి.
ఈ ఆకుపచ్చ దీర్ఘ చతురస్రం మేము వాటిని అలా, కేవలం 3 పిక్సెల్స్ వెడల్పు ఉంది
చిత్రం 4 విస్తృత యొక్క బహుళ నిర్ధారించుకోండి అదనపు padding లో చేర్చండి ఉంది.
కాబట్టి ఆ మీరు ఇక్కడ ఈ 0 సె చూడండి ఎలా.
ఈ నిజానికి, మీ పునఃపరిమాణం pset ఫలితంగా ఉంటుంది
ముఖ్యంగా చిన్న బిట్మ్యాప్ తీసుకుని, 4 ద్వారా విస్తరించడం.
కాబట్టి మనం చూడండి, వాస్తవానికి ఈ చిత్రం 12 పిక్సెల్స్ వెడల్పు ఉంటుంది, కానీ 12 4 యొక్క బహుళ
మేము ఏ జోడించండి లేదు ఎందుకంటే మరియు అందువలన మేము నిజంగా చివరలో ఏ 0 సె చూడండి లేదు
ఇది పూర్తిగా మందంగా ఎందుకంటే. ఇది ఏ గది లేదు.
>> సరే. Padding గురించి ప్రశ్నలు?
సరే. కూల్.
>> నేను ముందు చెప్పినట్లుగా, బిట్ మ్యాప్ చిత్రాలన్నీ కేవలం బైట్లు క్రమం ఉంటాయి.
కాబట్టి మనం కలిగి బదులుగా బైట్ యొక్క ఖచ్చితంగా ఇది సంఖ్య ట్రాక్ అవసరం ఉంది
ఒక ప్రత్యేక ఎలిమెంట్ అనుగుణంగా, మేము నిజంగా ఆ సూచిస్తూ ఒక struct సృష్టించారు.
సో వాట్ మనం ఒక RGBTRIPLE struct ఉంది.
మీరు ఒక RGB ట్రిపుల్ ఒక ఉదాహరణకు ఉన్నప్పుడు,
ఈ రకం struct నిర్వచించే ఎందుకంటే, అప్పుడు మీరు, rgbtBlue వేరియబుల్ యాక్సెస్ చేయవచ్చు
సూచిస్తుంది, ఇది అదేవిధంగా ఆకుపచ్చ మరియు ఎరుపు వేరియబుల్స్, ఎంత నీలం, ఆకుపచ్చ, ఎరుపు మరియు,
వరుసగా మీరు.
>> మేము 0 to, ff కు ఆకుపచ్చ సెట్, నీలం వేరియబుల్ సెట్ అయితే
, మీరు కలిగి ఉండగల గరిష్ఠ విలువ, ఆపై ఎరుపు వేరియబుల్ 0 సెట్
అప్పుడు ఏమి రంగు ఈ ప్రత్యేక RGB ట్రిపుల్ ప్రాతినిధ్యం వహించే రీతిలో? >> [విద్యార్థి] గ్రీన్.
గ్రీన్. సరిగ్గా.
ఇది తెలిసిన ఉపయోగకరంగా చేస్తాడు మీరు ఒక RGB ట్రిపుల్ ఒక ఉదాహరణకు ఉన్నప్పుడు,
నీలిరంగు, ఆకుపచ్చ, ఎరుపు మరియు - - వేరుగా మీరు నిజంగా రంగు మొత్తం యాక్సెస్ చేయవచ్చు.
>> ఇప్పుడు మేము ఆ నిర్మాణం గురించి మాట్లాడారు చేసారు, యొక్క BMP ఫైల్ పరిశీలించి అనుమతిస్తుంది.
ఈ మీరు చేసిన structs ఉంటాయి.
ఇక్కడ మేము ఒక BITMAPFILEHEADER struct ఉన్నాయి.
ఆసక్తి పరిమాణం.
తరువాత, మేము మాకు ఆసక్తికరమైన అని కొన్ని విషయాలు ఉన్నాయి సమాచారం శీర్షిక, కలిగి
అవి పరిమాణం, వెడల్పు మరియు ఎత్తు.
మేము తరువాత లోకి వెళ్తారో, మీరు ఫైల్కు లో చదివినపుడు,
అది స్వయంచాలకంగా అదే ఉండడానికి సెట్ చేసిన ఎందుకంటే చదువుతుంది.
కాబట్టి biSize చిత్రం యొక్క అసలు పరిమాణం సంబంధించిన కుడి బైట్లు ఉంటాయి.
మేము గురించి మాట్లాడారు చేసిన మరియు ఇక్కడ, చివరకు, మేము RGBTRIPLE typedef struct ఉన్నాయి.
మేము దానికి సంబంధించిన ఒక rgbtBlue, గ్రీన్, మరియు Red ఉన్నాయి.
>> గ్రేట్. సరే.
ఇప్పుడు మేము బిట్ మ్యాప్ చిత్రాలన్నీ కొద్దిగా అర్థం, మనం ఒక ఫైల్ హెడర్ లేదని అర్థం
మరియు అది తో మరియు ఆ తర్వాత సంబంధం ఒక సమాచారం శీర్షిక, మేము ఆసక్తికరమైన కలిగి
రంగుల, మరియు ఆ రంగులను, RGBTRIPLE structs సూచించబడతాయి
మరియు ఆ, క్రమంగా, ఆకుపచ్చ, నీలం, మరియు ఎరుపు సంబంధం మూడు విలువలు కలిగి ఉంటాయి.
>> కాబట్టి ఇప్పుడు, మనం ఒక బిట్ పునరుద్ధరించు ఆలోచించండి రకం చెయ్యవచ్చు.
క్షమించాలి. హూడన్ఇట్ గురించి ఆలోచించండి.
మేము మా క్లూ ఫైలుని కలిగి ఉంటే, అప్పుడు మనం చేయాలనుకుంటున్నారా దానికి పిక్సెల్ ద్వారా పిక్సెల్ లో చదవబడుతుంది
మేము ఒక చదవగలిగే రూపంలోకి అవుట్పుట్ విధంగా మరియు తరువాత ఏదో ఆ పిక్సెళ్ళు మార్చండి.
మరియు అందువలన అవుట్పుట్, మేము verdict.bmp ఫైల్లోకి పిక్సెల్ ద్వారా పిక్సెల్ ఎలా రాయాలో చేస్తున్నారు.
ఆ విధంగా చేయడానికి చాలా యొక్క ఉంటాము. మేము గుర్తిస్తారు.
కాబట్టి మనం చేసిన మేము నిజంగా మీకు అందించిన ఉంది copy.c.
ఏ copy.c చేస్తుంది కేవలం ఒక Bitmap ఫైల్ యొక్క ఖచ్చితమైన కాపీని చేస్తుంది మరియు అప్పుడు అందిస్తుంది ఉంది.
కాబట్టి ఈ అప్పటికే, మీరు ఫైలు తెరుస్తుంది పిక్సెల్ ద్వారా పిక్సెల్ లో చదువుతుంది
మరియు తర్వాత ఒక అవుట్పుట్ ఫైల్ లోనికి లో రాశాడు.
>> యొక్క ఆ పరిశీలించి చూద్దాం.
ఇది సరైన వాడుక భరోసా ఉంది
ఇక్కడ ఫైల్ పొందడానికి.
ఈ చేస్తుంది, అది మేము ఇక్కడ infile లో జారీ చేసిన వాటిని అని ఇన్పుట్ ఫైల్ అమర్చుతుంది ఉంది
ఇది మా రెండవ ఆదేశ పంక్తి వాదన ఉంది.
మేము ఫైల్ను తెరవడం నిర్ధారించండి తనిఖీ చేస్తుంది.
మేము ఇక్కడ ఒక కొత్త outfile చేయవచ్చు నిర్ధారించడానికి తనిఖీ చేస్తుంది.
ఈ ఇక్కడ ఏమి, అది కేవలం ప్రాథమికంగా ప్రారంభం నుండి Bitmap ఫైల్ కు చదవడం ప్రారంభిస్తాడు.
ప్రారంభంలో, మేము తెలిసిన, BITMAPFILEHEADER కలిగి
అందువలన బిట్ల ఆ శ్రేణులు నేరుగా BITMAPFILEHEADER పూర్తి చేస్తుంది.
కాబట్టి మనం ఇక్కడ కలిగి BITMAPFILEHEADER BF అని -
ఆ రకం BITMAPFILEHEADER మా వేరియబుల్ -
మేము పాయింటర్ లో నుండి చదివిన వాటిని BF లోపల పెట్టి చూడాలని, ఇది మా infile ఉంది.
మేము ఎంత చదివే?
మేము మొత్తం BITMAPFILEHEADER కలిగి ఉండాలి ఎన్ని బైట్లు లో చదవండి.
అదేవిధంగా, ఆ సమాచారం శీర్షిక కోసం మేము ఏమి.
కాబట్టి మేము, infile లో మా ఫైలు పాటు కొనసాగే చేస్తున్నారు
మరియు మేము ఆ బిట్స్ మరియు బైట్లు చదువుతున్న, మరియు మేము నేరుగా వాటిని పూరించే చేస్తున్నారు
మేము చేస్తున్న ఆ చరరాశుల ఈ సందర్భాల్లో లోకి.
ఇక్కడ మేము బిట్మ్యాప్ బిట్మ్యాప్ను అని మీరు మీరు చేస్తున్నారు.
>> ఇప్పుడు మేము, ఒక outfile ఉందా?
మేము దీన్ని సృష్టించడానికి ఇది ఉంది కనుక, ఇది ఖాళీ.
కాబట్టి మేము ప్రధానంగా మొదటి నుండి ఒక కొత్త బిట్మ్యాప్ సృష్టించడానికి ఉన్నాయి.
మనం చెయ్యవలసింది మేము ఫైల్ శీర్షికలో కాపీ అని మీరు తయారు చేసుకోవాలి ఉంది
మరియు కేవలం infile వంటి సమాచారం శీర్షిక ఉంది.
మరియు BF వేరియబుల్ అని గుర్తుంచుకోండి - మనం చెయ్యవలసింది మేము వ్రాయడానికి ఉంది
రకం BITMAPFILEHEADER యొక్క, మనం చెయ్యవలసింది మేము ఆ కంటెంట్ను ఉపయోగించడానికి కనుక
outfile లోకి రాయడానికి.
ఇక్కడ, మేము padding గురించి మాట్లాడారు గుర్తు
అది మేము కలిగి పిక్సెళ్ళు మొత్తం 4 యొక్క బహుళ నిర్ధారించుకోండి ముఖ్యం ఎలా.
ఈ మీరు ఎంత padding గణించడానికి ఒక అందమైన ఉపయోగకరమైన సూత్రం
మీ ఫైల్ యొక్క వెడల్పు ఇచ్చిన.
నేను మీరు అబ్బాయిలు copy.c లో మేము padding లెక్కించడానికి ఒక ఫార్ములా కలిగి గుర్తుంచుకోవాలనుకుంటున్న.
సరేనా? కాబట్టి ప్రతి ఒక్కరూ గుర్తుంచుకోవాలి. గ్రేట్.
కాబట్టి అప్పుడు copy.c ఏమి పక్కన scanlines పై iterates ఉంది.
ఇది మొదటి వరుసలు ద్వారా వెళుతుంది మరియు అప్పుడు అది చదివే ప్రతి ట్రిపుల్ నిల్వ
ఆపై outfile లో రాశాడు.
కాబట్టి ఇక్కడ మేము ఒక సారి ఒక RGB ట్రిపుల్ చదువుతున్న
ఆపై outfile ఆ అదే ట్రిపుల్ నిలిపివేసింది.
గమ్మత్తైన భాగంగా, padding ఒక RGB ట్రిపుల్ కాదు
అందువలన మేము RGB ట్రిపుల్స్ ఆ padding మొత్తం చదువలేదు.
మనం లేదు నిజానికి, మా ఫైలు స్థానం సూచిక తరలించడానికి మా కర్సరును మరల్చటానికి ఉంది
రాబోయే వరుస వద్ద ఉన్నట్లు కాబట్టి అన్ని padding పైగా skip యొక్క రకాన్ని.
మరియు ఈ ఏమి కాపీని మీరు padding జోడించదలచిన ఎలా మీరు చూపిస్తుంది ఉంటుంది.
కాబట్టి మేము, మేము అవసరం ఎంత padding లెక్కించిన చేసిన
కాబట్టి మేము 0 సె యొక్క padding సంఖ్య ఉండాలి.
ఈ చేస్తుంది మా outfile లోకి 0 సె యొక్క padding సంఖ్యను ఆ లూప్ ఒక ఉంది.
మరియు తర్వాత చివరిగా, మీరు రెండు ఫైళ్లను మూసివేయండి. మీరు infile అలాగే outfile మూసివేయండి.
>> కాబట్టి ఆ ఎలా copy.c రచనలు,
మరియు ఆ అందంగా ఉపయోగకరంగా చెప్పారు.
బదులుగా కేవలం వాస్తవానికి నేరుగా కాపీ మరియు పేస్ట్ యొక్క
లేదా, అది చూడటం మరియు మీరు కావలసిన లో టైప్
మీరు, టెర్మినల్ లో ఈ ఆదేశమును నిర్వర్తించుటకు ఉంటుంది
ఒక కొత్త ఫైల్ సృష్టిస్తుంది ఇది cp copy.c whodunit.c, whodunit.c,
ఆ కాపీ చేస్తుంది వంటి ఖచ్చితమైన కంటెంట్ను కలిగి ఉంది.
కాబట్టి అప్పుడు మేము ఏమి ఒక చట్రాన్ని తర్వాత నిర్మించడానికి మరియు సవరించడానికి ఆ వినియోగాన్ని
మా హూడన్ఇట్ ఫైల్ కోసం.
>> ఈ మా కు-DOS హూడన్ఇట్ కోసం ఏమి ఉంటాయి, కానీ copy.c చేస్తుంది
వాస్తవానికి మాకు వాటిని చాలా జాగ్రత్తగా తీసుకుంటుంది.
కాబట్టి మేము తర్వాత ఏమి చేయాలి అన్ని అవసరమైన పిక్సెళ్ళు మార్పు
నిజానికి ఫైల్ చదవగలిగేటట్లు.
రకం RGBTRIPLE ఇచ్చిన వేరియబుల్ కోసం కాబట్టి, ట్రిపుల్ ఒక పిక్సెల్ కోసం గుర్తుంచుకోండి
మీరు నీలం, ఆకుపచ్చ, ఎరుపు మరియు విలువలు యాక్సెస్ చేయవచ్చు.
ఆ ఉపయోగపడుట వెళుతున్న మీరు వాటిని యాక్సెస్ చేయవచ్చు ఉంటే ఎందుకంటే,
మీరు కూడా, వాటిని తనిఖీ చేయవచ్చు అర్థం
మరియు మీరు కూడా వారిని మార్చవచ్చు అర్థం.
>> కాబట్టి మేము మా ఎరుపు భూతద్దం ఉదాహరణకు తిరిగి వెళ్లాడు,
ప్రధానంగా, మాకు కోసం ఫిల్టర్ ఒక విధమైన గా ఉన్నాడు.
కాబట్టి మనం చేయాలనుకుంటున్నారా మేము సైన్ వస్తున్నాయి ఆ ట్రిపుల్స్ అన్ని వడపోత మీరు ఉంటుంది
దీన్ని అనేక భిన్నమైన మార్గాలు ఉన్నాయి.
సాధారణంగా, మీరు మీకు కావలసిన వడపోత యొక్క ఏ రకం కలిగి ఉంటాయి.
బహుశా మీరు అన్ని Red పిక్సెళ్ళు మార్చడానికి కావలసిన
లేదా మీరు వేరే రంగు వేరొక రంగు పిక్సెల్ మార్చడానికి కావలసిన.
ఆ మీ ఇష్టం.
మీరు పిక్సెల్ ఏ రంగు తనిఖీ గుర్తుంచుకోండి
మీరు ద్వారా వెళుతున్న మరియు అప్పుడు మీరు కూడా మార్చవచ్చు.
>> సరే. కాబట్టి ఆ హూడన్ఇట్ ఉంది.
ఒకసారి మీరు హూడన్ఇట్ అమలు, మీరు నేర నేరస్థుడు అయిన తెలుసు ఉంటాం.
>> ఇప్పుడు మేము పునఃపరిమాణం వెళ్ళండి చూడాలని.
మేము ఇంకా బిట్ మ్యాప్ చిత్రాలన్నీ వ్యవహరించే కావడం చేస్తున్నారు.
మేము ఉంటుంది చేయబోతున్నామని మనం ఒక ఇన్పుట్ బిట్మ్యాప్ చూడాలని
మరియు తర్వాత మేము అనేక పాస్ ఆపై ఒక outfile బిట్మ్యాప్ పొందడానికి వెళుతున్న
ప్రాథమికంగా n ద్వారా స్కేల్ మా infile ఎక్కడ.
నా ఫైలు కేవలం ఒక పిక్సెల్ పెద్ద చెప్పడం.
నా n 3 3, స్కేలింగ్ ఉంటే అప్పుడు, అప్పుడు నేను, సార్లు ఆ పిక్సెల్ n సంఖ్య పునరావృతం చేశారు
కాబట్టి 3 సార్లు, మరియు అప్పుడు కూడా 3 సార్లు అది డౌన్ స్కేల్.
కాబట్టి మీరు నేను అడ్డంగా నిలువుగా కూడా కొలిస్తే నేను చూడండి.
>> మరియు ఇక్కడ ఒక ఉదాహరణ ఉంది.
మీరు n = 2 కలిగి ఉంటే, మీరు మొదటి నీలం పిక్సెల్ రెండు సార్లు అక్కడ ప్రసారం చూడండి
అడ్డంగా రెండు సార్లు నిలువుగా అదే.
మరియు ఆ పై కొనసాగుతుంది, మరియు మీరు రెండు ద్వారా మీ అసలు చిత్రం యొక్క ఒక ప్రత్యక్ష స్కేలింగ్ ఉన్నాయి.
>> మేము ఈ కోసం వివరాలు pseudocode కు చేస్తే అప్పుడు, మేము ఫైల్ను తెరవడం మీరు.
ఆపై, మేము ఇక్కడ తిరిగి వెళ్లి ఉంటే తెలుసుకునేందుకు
మేము outfile కోసం వెడల్పు infile కోసం వెడల్పు కంటే భిన్నంగా అన్నారు చూసాము.
ఆ శతకము
మా శీర్షిక సమాచారాన్ని మార్చడానికి అన్నారు అర్థం.
కాబట్టి మనం చెయ్యవలసింది చెయ్యవచ్చును, శీర్షిక సమాచారం అప్డేట్ ఉంది
మీరు copy.c ఫ్రేమ్వర్క్ నిర్వహించడం మీరు మేము ఫైళ్లను చదివినపుడు అని ఎరిగి
మేము ఇప్పటికే పరిమాణం ఏమిటి సూచిస్తుంది మరియు ఆ వంటి వాటిని ఒక వేరియబుల్ ఉన్నాయి.
కాబట్టి మీరు మీరు ఏమి చెయ్యాలని అనుకుంటారు ఆ నిర్దిష్ట వేరియబుల్స్ మార్పు, ఆ ఉంటాయి.
మీరు ఒక struct ఉంటే ఆ లోపల వేరియబుల్స్ యాక్సెస్ ఎలా, గుర్తుంచుకోండి.
మీరు కుడి, డాట్ ఆపరేటర్లు ఉపయోగించాలి?
ఆ ఉపయోగించి కాబట్టి అప్పుడు, మీరు శీర్షిక మార్చు చేయాలి తెలుసు.
ఇక్కడ మీ ఫైల్ లో మార్పులు వెళ్ళే వాస్తవ అంశాల జాబితా ఉంది.
ఫైలు పరిమాణం, చిత్రం, అలాగే వెడల్పు మరియు ఎత్తు మార్పులు అన్నారు.
కాబట్టి అప్పుడు, బిట్ మ్యాప్ చిత్రాలన్నీ యొక్క మాప్ కు తిరిగి వెళ్ళడం
ఫైలు శీర్షిక లేదా సమాచారాన్ని కలిగి సమాచారం శీర్షిక అయినా చూడండి
మరియు అప్పుడు అవసరమైన మార్చండి.
మళ్లీ, cp copy.c resize.c చెప్పారు.
ఆ resize.c ఇప్పుడు కాపీ లోపల ఉన్న ప్రతి అంశం కలిగి అర్థం
కాపీ మాకు పిక్సెల్ ద్వారా ప్రతి scanline పిక్సెల్ కు reading ఒక మార్గాన్ని అందిస్తుంది ఎందుకంటే.
ఇప్పుడు తప్ప, బదులుగా మేము హూడన్ఇట్ లో చేసిన మాదిరిగా విలువలు మారుతున్న యొక్క,
మనం చేయాలనుకుంటున్నారా మేము అనేక పిక్సెల్స్ లో రాయాలనుకుంటున్నాను ఉంది
కాలం మా n 1 కంటే ఎక్కువ ఉంది.
>> అప్పుడు మనం చేయాలనుకుంటున్నారా, మేము n ద్వారా అడ్డంగా అది వదులు మీరు ఉంటుంది
అలాగే n ద్వారా నిలువుగా ఉంటుంది.
దీన్ని మేము ఎలా ఏమి ఉండవచ్చు?
మీ n 2 సే మరియు మీరు ఈ ఇచ్చిన infile ఉన్నాయి.
మీ కర్సర్, మొదటి స్థానంలో ఆరంభమవుతుంది ఉంది
n 2 ఉంటే మరియు మీరు ఏమి అనుకుంటున్నారా, మీరు వారిలో 2 ప్రింట్ మీరు.
ఆ యొక్క 2 ప్రింట్.
అప్పుడు మీ కర్సర్, ఎరుపు ఒకటి తర్వాత పిక్సెళ్ళు, తరలించాలని అన్నారు
మరియు అది ముందు ఏమి మీదకు అనుమతిస్తూ, ఆ ఎరుపు వాటిని యొక్క 2 ముద్రించాలా జరగబోతోంది.
అప్పుడు కర్సర్ తదుపరి పిక్సెల్ తరలించడానికి మరియు వారిలో 2 లో గీస్తాను.
మీరు ఇక్కడ ఈ ఏమి copy.c ఫ్రేమ్వర్క్, తిరిగి చూస్తే
అది ఒక RGB ట్రిపుల్, ట్రిపుల్ అని ఒక కొత్త కారకం యొక్క ఒక కొత్త ఉదాహరణకు సృష్టిస్తుంది ఉంది.
మరియు అది లో చదివి ఇక్కడ, అది infile 1 RGBTRIPLE నుండి చదువుతుంది
మరియు ఆ ట్రిపుల్ వేరియబుల్ యొక్క లోపల నిల్వ చేస్తుంది.
కాబట్టి మీరు నిజంగా ఆ ప్రత్యేక పిక్సెల్ ప్రాతినిధ్యం ఒక వేరియబుల్ ఉన్నాయి.
అప్పుడు మీరు ఏమి అనుకుంటారు ఏ, వ్రాస్తున్నప్పుడు లూప్ ఒక లోకి fwrite ప్రకటన కప్పు ఉంది
ఆ అవసరం సార్లు మీ outfile లో రాశాడు.
తగినంత సులభం.
జస్ట్ ప్రధానంగా వ్రాసే విధానాన్ని n అడ్డంగా ఇది స్కేల్ చెయ్యడానికి ఎన్నిసార్లు పునరావృతం.
>> కానీ మేము మా padding మార్చడానికి అన్నారు అని గుర్తుంచుకోండి.
గతంలో, మేము పొడవు 3 యొక్క విషయాలు ఉన్నాయి చెప్పారు.
అప్పుడు మేము ఎంత padding లో కలుపుతాయి? కేవలం ఒక ఎక్కువ 4 ఒక బహుళ చేస్తుంది.
కానీ మేము n = 2 ఈ ప్రత్యేక చిత్రం కొలిస్తే చేస్తున్నారు అనుకోండి.
కాబట్టి అప్పుడు ఎన్ని నీలం పిక్సెళ్ళు మేము చివరిలో ఉంది? మేము 6 ఉంటుంది.
1, 2, 3, 4, 5, 6. అన్ని కుడి.
6 4 బహుళ కాదు. 4 యొక్క సమీప బహుళ ఏమిటి? ఆ 8 చేస్తాడు.
కాబట్టి మేము నిజానికి అక్కడ padding యొక్క 2 అక్షరాలు చూడాలని.
>> మేము padding గణించడానికి ఒక ఫార్ములా ఉంటే ఎవరైనా గుర్తు
మరియు అని ఉంటుంది?
[వినబడని విద్యార్థి ప్రతిస్పందన] >> అవును, copy.c. కుడి.
మీరు ఎంత padding లెక్కించేందుకు copy.c ఒక ఫార్ములా ఉంది
బిట్మ్యాప్ చిత్రం యొక్క ఒక నిర్దిష్ట వెడల్పు ఇచ్చిన.
మీరు padding ఒక నిర్దిష్ట పరిమాణం జోడించడానికి కనుక అప్పుడు జరగబోతోంది ఆ ఉపయోగకరంగా ఉంటుందని
నిజానికి మీరు జోడించడానికి ఎంత padding గుర్తించడానికి.
కానీ ఒక గమనిక, అయితే, మీరు సరైన పరిమాణంలో ఉపయోగించి చేస్తున్న నిర్ధారించుకోవాలి ఉంది.
మీరు ప్రధానంగా రెండు బిట్మ్యాప్ చిత్రాల వ్యవహరించే కావడం ఉన్నందున జాగ్రత్త వహించాలి.
మీరు సరైన ఉపయోగించే ఆ నిర్ధారించుకోవాలి.
మీరు outfile కోసం padding గణన చేసినపుడు, మీరు outfile యొక్క వెడల్పు ఉపయోగించాలనుకుంటున్నాను
మరియు ముందు వెడల్పును.
>> గ్రేట్. ఆ రకమైన అడ్డంగా మొత్తం బిట్మ్యాప్ చిత్రం సాగదీయడం గురించి జాగ్రత్త తీసుకుంటుంది.
కానీ మేము మీరు ఏమి నిజంగా నిలువుగా కూడా పొడిగించబడింది ఉంది.
ఈ మేము వరుసగా కాపీ పూర్తి చేసినప్పుడు ఎందుకంటే కొంత trickier అవతరిస్తుంది
మరియు ఆ వరుస రాయడం, మా కర్సర్ ముగింపు వద్ద అన్నారు.
మేము మళ్లీ చదవండి కాబట్టి, అది తర్వాతి లైన్ కు చదవడానికి జరగబోతోంది.
కాబట్టి మనం చేయాలనుకుంటున్నారా మళ్లీ ఆ వరుసలు కాపీ కొన్ని మార్గాన్ని రకమైన ఉంది
లేదా ఆ వరుస తీసుకుని, దాన్ని మళ్ళీ మళ్లీ చూస్తూ ఉంటాము.
నేను రకమైన పేర్కొన్నట్లు, ఈ చేయడానికి వివిధ మార్గాలు ఉన్నాయి.
మీరు ద్వారా వెళ్లి ప్రత్యేక scanline ద్వారా చదువుతున్న వంటి మీరు ఏమి కాలేదు ఉంది
మరియు అవసరమైన దానిని మార్చడం, అప్పుడు స్టోర్ రకం వ్యూహంలో ఆ పిక్సెళ్ళు అన్ని.
తరువాత మీరు మీరు మళ్ళీ ఆ శ్రేణి ముద్రించాలా చేయాలి తెలుసు,
అందువలన మీకు ఆ శ్రేణి ఉపయోగించవచ్చు.
దీన్ని మరొక విధంగా, మీరు ఒక వరుస డౌన్ కాపీ చేసుకోవడం వీలవుతుంది
మీరు దాన్ని మళ్ళీ కాపీ అవసరమైన అర్థం, కనుక వాస్తవానికి, మీ కర్సరును మరల్చటానికి
మరియు ఆ పద్ధతి fseek ఉపయోగించి చేస్తాడు.
మీరు తిరిగి మీ కర్సర్ అన్ని మార్గం తరలించి, తర్వాత మళ్ళీ కాపీ విధానాన్ని పునరుక్తి కాలేదు.
>> మా స్కేలింగ్ సంఖ్య n ఉంటే కాబట్టి, అప్పుడు ఎన్ని సార్లు మేము తిరిగి వెళ్లి వుంటుంది
మరియు ఒక లైన్ తిరగరాసే? >> [విద్యార్థి] n - 1. >> అవును, ఖచ్చితమైన. n - 1.
మేము ఒకసారి ఇప్పటికే చేశాను, అందువల్ల మేము వెళ్లి తిరిగి విధానాన్ని పునరుక్తి చెయ్యవచ్చును
n - టైమ్స్ యొక్క 1 మొత్తం.
సరే. సో అక్కడ మీరు మీ పునఃపరిమాణం చర్య.
>> ఇప్పుడు మేము ఒక నిజంగా సరదాగా భాగంగా, పునరుద్ధరించు ఇది నా ఇష్టమైన pset, పొందవచ్చు.
బదులుగా బిట్ మ్యాప్ చిత్రాలన్నీ ఈ సమయంలో మేము JPEGs వ్యవహరించే చేస్తున్నారు.
మేము నిజానికి JPEGs ఒక ఫైల్ ఇచ్చిన లేదు,
మేము ప్రాథమికంగా ఒక ముడి మెమరీ కార్డ్ ఫార్మాట్ ఇచ్చిన చేస్తున్నారు.
కాబట్టి ఈ, ప్రారంభంలో సమాచారం మరియు చెత్త విలువలు బిట్ కలిగి
మరియు అప్పుడు మొదలవుతుంది మరియు JPEG ఫైళ్లు కొంత ఉంది.
మేము ఫోటోలు తొలగించారు పేరు అయితే, మేము ఒక కార్డు అందజేశారు చేస్తున్నాము;
ఫోటోలు కార్డు లోపల ఉన్న ముఖ్యమైన, మేము ను మర్చిపోతే.
కాబట్టి అప్పుడు పునరుద్ధరించు లో మా పని ఈ కార్డు ఫార్మాట్ ద్వారా వెళ్ళడానికి ఉంది
మళ్ళీ ఆ చిత్రాలు చూడండి.
>> అదృష్టవశాత్తు, JPEG ఫైళ్లు మరియు కార్డు ఫైలు యొక్క నిర్మాణం ఒక బిట్ ఉపయోగకరంగా ఉంటుంది.
ఈ ప్రత్యేక ఫార్మాట్లో ఒకవేళ ఇది ఖచ్చితంగా ఒక బిట్ trickier ఉండేవి.
ప్రతి JPEG ఫైల్ నిజానికి పైన జాబితా రెండు సాధ్యం సన్నివేశాలు, మొదలవుతుంది.
సాధారణంగా, మీరు ఒక కొత్త JPEG ఫైలు, ఉన్నప్పుడు
ఇది శ్రేణిని ffd8 ffe0 లేదా ఇతర ఒకటి ffd8 ffe1 గాని మొదలవుతుంది.
తెలిసిన మరో ఉపయోగపడిందా విషయం JPEGs పక్కపక్కన నిల్వ ఉంటుంది.
కాబట్టి ఒక JPEG ఫైల్ ముగుస్తుంది చేసినప్పుడు ఇతర ఒక ప్రారంభమవుతుంది.
సో అక్కడ విలువలు మధ్య ఎలాంటి లేదు.
మీరు ఇప్పటికే ఒక JPEG reading అయితే మేము మీరు,, ఒక JPEG ప్రారంభంలో హిట్
మీరు ముందు మరియు తరువాత ఒక ప్రారంభంలో ముగింపు హిట్ చేసిన తెలుసు.
>> ఈ ఊహించడానికి యొక్క రకాన్ని, నేను ఒక సాధారణ చేసింది.
JPEGs గురించి మరొక విషయం, మేము ఒక సమయంలో 512 బైట్లు శ్రేణులలో వాటిని చదువుకోవచ్చు ఉంది
అదేవిధంగా కార్డు ప్రారంభంలో తో.
మేము ఆ కుడుచు ఎందుకంటే ప్రతి బైట్ తనిఖీ అవసరం లేదు.
కాబట్టి బదులుగా, వాట్ వి కాన్ డు నిజానికి ఒక సమయంలో 512 బైట్లు చదవబడుతుంది
తరువాత, బదులుగా ఆ చిన్న చిన్న ముక్కలు ఆ మధ్య లో తనిఖీ యొక్క,
మేము కేవలం 512 బైట్లు ప్రారంభంలో తనిఖీ చేయవచ్చు.
ముఖ్యంగా, ఈ చిత్రంలో, మీరు చూడండి, కార్డు ప్రారంభంలో ఉంది
మీరు నిజమైన JPEGs తమను తాము నిజంగా సంబంధిత లేని విలువలు కలిగి ఉంటాయి.
కానీ నేను కలిగి JPEG రెండు ప్రారంభ వరుస క్రమాల యొక్క ఒక సూచించడానికి ఒక నక్షత్రం.
కాబట్టి మీరు ఒక స్టార్ చేసినప్పుడు, మీరు ఒక JPEG ఫైల్ ఉందని మాకు తెలుసు.
తర్వాత ప్రతి JPEG ఫైల్ 512 బైట్లు కొన్ని బహుళ అవతరిస్తుంది
కానీ అదే బహుళ అవసరం.
మీరు మరొక స్టార్ కొట్టినప్పుడు మీరు మరొక JPEG హిట్ చేసిన తెలిసిన విధంగా, ఉంది
బైట్లు యొక్క మరొక ప్రారంభ సన్నివేశం.
అప్పుడు ఇక్కడ ఉన్నాయి మీరు ఒక స్టార్ హిట్ వరకు మీరు, నిరంతర ఎరుపు JPEG ఫైలుని కలిగి ఉంది
ఒక కొత్త రంగు సూచిస్తుంది.
మీరు కొనసాగించి తరువాత మీరు మరొక స్టార్ హిట్, మీరు మరొక JPEG హిట్
మీరు చివరి వరకు అన్ని మార్గం కొనసాగుతుంది.
మీరు ఇక్కడ చివరి చిత్రం లో పింక్ ఒకరు.
మీరు ఫైల్ పాత్ర చివరికి హిట్ వరకు మీరు ముగింపు వెళ్ళండి.
ఇది నిజంగా ఉపయోగకరంగా అన్నారు.
>> ఇక్కడ కొన్ని ప్రధాన takeaways:
కార్డు ఫైలు, ఒక JPEG ప్రారంభం లేదు
ఒక JPEG మొదలవుతుంది ఒకసారి కానీ, JPEGs అన్ని పక్క మరొక వైపు నిల్వ చేయబడతాయి.
>> పునరుద్ధరించు కోసం కొన్ని pseudocode.
మొదటి, మేము, మా కార్డు ఫైల్ను తెరవడం చూడాలని
మరియు మా ఫైలు I / O ఫంక్షన్లను ఉపయోగించి చేస్తాడు.
మేము ఫైల్ ముగింపు చేరుకున్నారు వరకు విధానాన్ని పునరుక్తి చూడాలని.
మేము ఒక సమయంలో 512 బైట్లు చదవండి చూడాలని.
మరియు నేను ఏ ఇక్కడ చెప్పారు, మేము ఒక బఫర్ లో నిల్వ చూడాలని ఉంది
మేము వారితో చేయడానికి ఖచ్చితంగా ఏమి వరకు ప్రధానంగా ఆ 512 బైట్లు పట్టు.
అప్పుడు మనం చేయాలనుకుంటున్నారా మేము ఒక స్టార్ లేదా హిట్ చేసిన లేదో తనిఖీ దీనిని చేస్తారు.
మేము ప్రారంభ వరుస క్రమాల యొక్క ఒక హిట్ ఉంటే, మేము ఒక స్టార్ హిట్ ఉంటే,
అప్పుడు మేము ఒక కొత్త JPEG ఫైల్ హిట్ చేసిన తెలుసు.
ఉంది మేము చెయ్యవచ్చును మనం మా pset4 డైరెక్టరీలో కొత్త ఫైలును సృష్టించాలనుకునే చూడాలని
ఫైల్ తయారు చెయ్యండి.
కానీ, ఇప్పటికే, ముందు ఒక JPEG చేసిన ఉంటే
అప్పుడు మేము, ఆ ఫైల్ ముగింపు మరియు pset4 ఫోల్డర్కు ఇది పుష్ మీరు
ఆ ఫైల్ను నిల్వ ఉంటుంది పేరు మేము JPEG ఫైల్ ముగిసిన చేసిన పేర్కొనండి లేకపోతే ఎందుకంటే,
అప్పుడు మేము ప్రధానంగా ఒక అనిర్దిష్ట మొత్తం ఉంటుంది. JPEGs అంతం కాదు.
కాబట్టి మేము, మేము ఒక JPEG ఫైల్ కు చదవడం మరియు చేసినప్పుడు రాయడం ఆ నిర్ధారించుకోవాలి
మేము ప్రత్యేకంగా తదుపరి తెరవండి చేయడానికి ఆ మూసివేయాలని మీరు అనుకుంటున్నారా.
మేము అనేక విషయాలను తనిఖీ చెయ్యవచ్చును.
మేము మా బఫర్ ఒక కొత్త JPEG ప్రారంభంలో ఉన్నారు లేదో తనిఖీ కావలసిన
మరియు మేము ఇప్పటికే ముందు ఒక JPEG కనుగొన్నారు ఉంటే
ఎందుకంటే కొంచెం మీ ప్రక్రియ మారుతుంది.
మీరు అన్ని మార్గం గుండా వెళ్లి, తరువాత మీరు, ఫైలు ముగింపు హిట్
అప్పుడు మీరు ఏమి చేయాలి మీరు ప్రస్తుతం ఉంటాయి అన్ని ఫైల్స్ దగ్గరగా చెయ్యవచ్చును ఉంది.
ఆ బహుశా, మీరు కలిగి గత JPEG ఫైల్ ఉంటుంది
అలాగే కార్డ్ ఫైల్ వలె మీరు జరుపుతోంది చేసిన.
>> మేము పరిష్కరించడానికి అవసరమైన చివరి అడ్డంకి అసలైన JPEG ఫైల్ తయారు ఎలా
మరియు వాస్తవానికి ఫోల్డర్కు ఇది పుష్ ఎలా.
pset, మీరు కనుగొనడానికి ప్రతి JPEG కింది ఫార్మాట్ ఉండాలి
మీరు కలిగి ఉన్నారు. jpg.
సంఖ్య, అది 0 అయినా, మేము ఇది 000.jpg కాల్.
మీరు, మీ ప్రోగ్రామ్ ఒక JPEG కనుగొనేందుకు ఎప్పుడు
మీరు ఉండే ఆ క్రమంలో అది పేరు పెట్టాలనుకున్న చూడాలని.
దీని అర్థం ఏమిటి?
మేము కనుగొన్నాము ఎన్ని ట్రాక్ రకమైన అవసరం
మరియు ప్రతి JPEG యొక్క సంఖ్య ఏ.
ఇక్కడ మేము sprintf పనితీరు ప్రయోజనాన్ని చూడాలని.
, Printf లాగానే ఇది టెర్మినల్కు అచ్చుల కేవలం రకం విలువ అవ్ట్,
sprintf ఫోల్డర్ లోకి ఫైలు అవుట్ ముద్రిస్తుంది.
కాబట్టి ఈ, అక్కడ స్ట్రింగ్ అప్పుడు నేను sprintf, శీర్షిక కలిగి ఉంటే ఏమి, మరియు ఉంటుంది
అది 2.jpg ముద్రించాలా చేస్తుంది.
నేను సరిగ్గా నా ఫైళ్లను మూసివేసినట్లయితే ఊహిస్తే
ఆ నేను రాసిన ఆ ఫైల్ కలిగి ఉంటుంది.
కానీ ఒక విషయం అని నేను ఇక్కడ కలిగి కోడ్
చాలా pset అవసరం ఏమి సంతృప్తి లేదు.
pset రెండవ JPEG ఫైల్ బదులుగా కేవలం 2 యొక్క 002 పేరుతో అవసరం.
కాబట్టి మీరు పేరు ముద్రించాలా ఉన్నప్పుడు, అప్పుడు బహుశా మీరు కొద్దిగా ప్లేస్హోల్డర్ మార్పు చేయవచ్చు.
>> ఎవరైనా ఏదో ప్రింట్ మేము అదనపు ఖాళీలను వీలు ఎలా గుర్తు?
అవును. >> [విద్యార్థి] మీరు శాతం సైన్ మరియు 2 మధ్య 3 ఉంచండి. >> అవును, ఖచ్చితమైన.
మేము 3 స్థలాన్ని మీరు మీరు ఈ సందర్భంలో ఒక 3 ఉంచుతాము.
% 3D బహుశా మీరు 002.jpg బదులుగా 2 ఇస్తుంది.
sprintf ఫంక్షన్ లో మొదటి వాదన, అసలైన చార్ శ్రేణి
ఇది మేము గతంలో స్ట్రింగ్స్ తెలుసు.
వారు, ఒక తాత్కాలిక నిల్వ వలె రకం, కేవలం ఫలితంగా స్ట్రింగ్ నిల్వ.
మీరు నిజంగా ఈ వ్యవహరించే కాదు, కానీ మీరు దాన్ని చేర్చడానికి అవసరం.
>> ప్రతి ఫైల్ పేరు మూడు అక్షరాలు తీసుకుంటుంది ఇది సంఖ్య కలిగి ఉంది అని తెలుసుకుంటే,
మరియు తర్వాత. jpg, ఈ శ్రేణి ఎంత ఉండాలి?
అనేక అవుట్ త్రో. పేరు టైటిల్ లో ఎంత మంది అక్షరాలు,?
కాబట్టి 3 hashtags, కాలం, jpg ఉంది. >> [విద్యార్థి] 7. >> 7. కాదు.
మేము అదే శూన్య టెర్మినేటర్ అనుమతించాలనుకుంటున్న ఎందుకంటే మేము 8 మీరు చూడాలని.
>> చివరగా, కేవలం, మీరు పునరుద్ధరించు కోసం చేస్తూ ఉంటాను ఆ ను డ్రా
మీరు కొన్ని ప్రారంభంలో సమాచారం.
మీరు ఒక JPEG ఫైల్ ప్రారంభంలో కనుగొనేందుకు వరకు మీరు, కొనసాగించటానికి
మరియు ఆ రెండు ప్రారంభ క్రమాల గాని ఉంటుంది.
మీరు చదివే ఉంటాను. ఇక్కడ ప్రతి స్లాష్ 512 బైట్లు సూచిస్తుంది.
మీరు మరొక ప్రారంభ క్రమాన్ని ఎదుర్కునే వరకు చదివే చేస్తూనే, పఠనం చేస్తూనే.
మీరు, మీరు ప్రస్తుత JPEG ముగించి కలిగి - ఈ సందర్భంలో, ఎరుపు ఒకటి,
కాబట్టి మీరు చివరికి మీరు.
మీరు, మీ pset4 ఫోల్డర్ ఆ యొక్క sprintf పేరు అనుకుంటున్నారా
అప్పుడు మీరు ఒక కొత్త JPEG తెరిచేందుకు మరియు తరువాత చదివిన తరువాత ఉంచాలని
మీరు తదుపరి ఎదుర్కునే వరకు.
, పఠనం చేస్తూనే, పఠనం న ఉంచండి
మరియు తర్వాత చివరకు, చివరికి, మీరు, ఫైలు ముగింపు చేరుకోవడానికి వెళుతున్న
మరియు మీరు, మీరు పని చేసిన చివరి JPEG దగ్గరగా చెయ్యవచ్చును
sprintf మీ pset4 ఫోల్డర్ లోకి, ఆపై మీరు సంపాదించిన చేసిన చిత్రాలను అన్ని చూడండి ఆ.
ఆ చిత్రాలు వాస్తవానికి CS50 సిబ్బంది చిత్రాలు ఉన్నాయి
pset యొక్క బోనస్ సరదాగా భాగంగా వస్తుంది కాబట్టి ఈ ఉంది
మీరు చిత్రాలను లో TFS కనుగొనడానికి మీ విభాగాలలో పోటీ ఉంటుంది
మరియు వారితో చిత్రాలు తీసుకుని మీరు pset చేసిన నిరూపించడానికి
మరియు మీరు సిబ్బంది చిత్రాలు ఉన్నాయి చూడగలరు.
కాబట్టి మీరు సిబ్బంది చిత్రాలను తీయండి. కొన్నిసార్లు మీరు వాటిని తరుముతూ ఉంటుంది.
బహుశా వాటిని కొన్ని మీరు నుండి తప్పించుకొనే ప్రయత్నించండి.
మీరు వారితో చిత్రాలను తీయండి.
ఈ కొనసాగుతోంది. Pset వలన అది కారణంగా కాదు.
గడువు స్పెక్ లో ప్రకటిస్తారు.
అప్పుడు కలిసి మీ విభాగం, ఏది విభాగం అత్యంత చిత్రాలు పడుతుంది
అత్యంత సిబ్బంది ఒక చాలా అద్భుతంగా బహుమతి గెలుచుకున్న కనిపిస్తుంది.
పొందడానికి ప్రోత్సాహక రకంగా మీ pset4 వీలైనంత త్వరగా పూర్తి
అప్పుడు మీరు వ్యాపార క్రిందికి పొందవచ్చు ఎందుకంటే
అన్ని వివిధ CS50 సిబ్బంది డౌన్ వేట.
తప్పనిసరి కాదని, కనుక మీరు, చిత్రాలు పొందండి
అప్పుడు మీరు pset4 పూర్తి.
>> మరియు నేను వచ్చే అన్ని ధన్యవాదాలు, Walkthrough 4 నిలిచాడు చేస్తున్నాను.
ఫోరెన్సిక్స్ తో అదృష్టం. [చప్పట్లు]
[CS50.TV]