» »

[Python] Domači nalogi

[Python] Domači nalogi

rajko_car ::

Živjo!
Zanima me če pozna kdo python in bi mi pomagal rešiti tile dve nalogi? Sem začetnik in mi res ne gre...

I. Prebereš 7 števil. Med njimi poiščeš tista, ki so deljiva z x. Program naj izpiše vsako število, na koncu pa kolikšna je vsota vseh števil.
II. Ustvari .txt datoteko v kateri bodo imena prijateljev in njihov kraj bivanja. Ustvari novo .txt datoteko v kateri bodo samo prijatelji, ki so doma v/iz npr. Ljubljane (en kraj).

hvala!
  • spremenil: Mavrik ()

Gandalfar ::

Domacih nalog naceloma ne resujemo. Pokazi kaj imas in kje se ti zatakne in ti bomo pomagali.

rajko_car ::

to sem uspel narediti:
I. naloga:
n=0
m=0
seznam=[]
x=input("Število x: ")

while n < 7 :
n = n+1
a=input("Poljubno število: ")
if a%x==0:
seznam.append(a)
m=m+a

print "Števila so:",seznam
print "Vsota:",m


II. Naloga
prijatelji=open("prijatelji.txt","w")
prijateljiljubljana=open("prijateljiljubljana.txt","w")

vrstica=["Kraj1,Ime1 Priimek1", "Kraj2, Ime2 Priimek2", "..."]

prijatelji.write("\n".join(vrstica))
prijatelji.close()
prijatelji=open("prijatelji.txt","r")

for line in prijatelji.readlines():
if line [0:3]=="Lj":
prijateljiljubljana.write(line)

prijatelji.close()
prijateljiljubljana.close()

rajko_car ::

z II. nalogo sem zadovoljen, mi vse lepo izpiše, pri I. pa še vedno nimam razčiščeno kaj točno vse naj bi se mi izpisalo...

krneki0001 ::

Sicer napisano v Ruby-ju, dela pa samo za integerje, ampak boš verjetno dojel kaj dela in boš pretvoril v python. Najbrž ti ne bo težko, glede na to, da sta si jezika kr dost podobna.
Edino pretvori cifre v float, da boš lahko delal z decimalkami.

puts "Vpisi stevilo X:"
stevilo_x = gets.chomp.to_i
ary=[]
for i in 0..6
	j = i + 1
	puts "Vpisi #{j}. stevilo"
	ary[i] = gets.chomp.to_i
end
puts "Izpis vseh stevil : #{ary.join(' , ')} , deljitelj je #{stevilo_x}"

vsota = 0
ary_d=[]
z = 0
for k in 0..6
	if ary[k] % stevilo_x == 0
		vsota = vsota + ary[k]
		ary_d[z] = ary[k]
		z = z + 1
	end
end
puts "stevila deljiva z #{stevilo_x} so : #{ary_d.join(' , ')} , vsota teh stevil je : #{vsota}"


Pri nas smo imel srečo, da so bili nekateri profesorji tok dobri, da so rekl, ni važen programski jezik, ampak rezultat in tako smo lahko delal v tistem, v čemur nam je pasalo.
Imam v Ruby-ju narejenih ogromno takih programov (okol 1GB različnih programčkov, skriptic in podobnega).
Asrock X99 Extreme 4 | Intel E5-2683V4 ES | 64GB DDR4 2400MHz ECC |
Samsung 250GB M.2 | Asus 1070 TI | 850W Antec | LC Tank Buster

Zgodovina sprememb…

invisable ::

Živjo=))

Jaz bi tudi zelo lepo prosila za pomoč, pri domači nalogi, kjer moramo podatke brati s spletne strani. Tema domače naloge so sicer regularni izrazi, ki jih razumem, vendar naloge ne morem rešiti, ker ne znam prebrati naloge z interneta.

Stran sem sicer poskusila prebrati na način:

import re, urlib.reqest
stran=urlib.request.urlopen("http://pef.uni-lj.si/47.html").read().d...
print(stran)

vendar to ne deluje.

Resnično zelo lepo bi vas prosila za pomoč, saj sem se prvič znašla v situaciji, ko ne berem npr. z neke datoteke ampak spletne strani.

ragezor ::

ja kaj je pa napaka? mogoce je napaka, ker mas tipkarske napake (urllib ma dva L)? uporabljas python3? stran sploh da kak odgovor?

evo popravljeno kodo brez tipkarskih napak
import urllib.request

stran = urllib.request.urlopen('http://pef.uni-lj.si/47.html', timeout=5).read()
print(stran)


na zalost http://pef.uni-lj.si/47.html stran ne deluje trenutno, zato sem ti dal timeout=5, da ti po 5 sekundah vrze error, ce ne dobi odgovora in ti ni treba cakat.

invisable ::

Najlepša hvala=))Sem popravila in sedaj dela.

technolog ::

Od nebiveduja rešitev napisana malo krajše, a z enako funkcionalnostjo (če koga zanima ruby):

puts 'Vnesi število x:'
x = gets.to_i

Array.new(7) { |i|
	puts "Vpiši #{i+1}. število:"
	gets.to_i
}.select { |n|
	n % x == 0
}.tap { |arr|
	puts "Števila deljiva z #{x} so: #{arr * ', '}; vsota je: #{arr.reduce :+}"
}

Zgodovina sprememb…

krneki0001 ::

technolog, saj se da še krajš kot si ti napisal, ampak za začetnike je bolje, če je pregledno, da razumejo kaj in kako. Sej potem se že počasi privajajo na manj kode in bližnjice\krajšanje kakršno si ti uporabil.
Asrock X99 Extreme 4 | Intel E5-2683V4 ES | 64GB DDR4 2400MHz ECC |
Samsung 250GB M.2 | Asus 1070 TI | 850W Antec | LC Tank Buster

technolog ::

Ne da se krajš :) Razen tega da vrednost neseš iz tapa v spremenljivko.

In se ne strinjam, da je za začetnika boljše. Ruby je jezik, kjer je for stavek tabu.

puts 'Vnesi število x:'
x = gets.to_i
 
arr = Array.new(7) { |i|
    puts "Vpiši #{i+1}. število:"
    gets.to_i
}.select { |n|
    n % x == 0
}
puts "Števila deljiva z #{x} so: #{arr * ', '}; vsota je: #{arr.reduce :+}"

Zgodovina sprememb…

invisable ::

Dober večer=))

Jaz mam spet eno veliko prošnjo v zvezi z domačo nalogo.

Kjer imam neko telefonsko številko in morem ven prebrat po skupinah 2-3 4-6 7-9 številko(AA BBB CCC)..

Sicer sem nekak skupej zmetala.. boste vidl pravi šmoren, ampak nekak dela za vse razen za predzadnji primer. Bi mi mogoče lahko kdo svetoval? tema pa so seveda regularni izrazi.

Moja rešitev je tako:
[+386]?[ \(]?\(?0\)?(\d{2})[\)\. / -]?[\)\. / -]?(\d{3})[\. -]?(\d{3})|

Testni primeri pa so:
040/555999
012351456
041-765-432
(031) 246-357
040/456-123
064.111-222
(051)121212
+386 041 100-200
00 386 (0)70 555 555
(051) 951-159
041234567
040 555-999
+386 (0)70 111 222
031 98 76 54
040/555999

Najlepša tistemu, ki mi bo odgovoril.

technolog ::

Kaj pa protiprimeri? A je 050//675/312 veljavna številka? Pa mogoče 0506789-31?

Predzadnji primer se ne da naredit samo z enim regexom.

Zgodovina sprememb…

invisable ::

import re
STEVILKE=re.compile("te vrstice mi žal noče poslati, ker v sebi nosi nedovoljeno HTML oznako")


telefonske=open("telefonske.txt",encoding="utf-8").read()

for telefonska in STEVILKE.finditer(telefonske):
a,b,c=str(telefonska.group("AA")),str(telefonska.group("BBB")),str(telefonska.group("CCC"))
print("0"+a+"/"+b+"-"+c)

tole je moj program... kar izpiše pa je:

051/123-456
041/765-432
031/246-357
040/456-123
064/111-222
051/121-212
0None/None-None
0None/None-None
0None/None-None
041/100-200
0None/None-None
070/555-555
051/951-159
041/234-567
040/555-999
070/111-222
040/555-999

Žal ne vem kje je napaka.

Sicer pa nismo dobili nobenih ostalih primerov.. Sama se z njimi obadam že cel dan:S bom še malo premislila, ampak ne vem če bo še kaj zraslo na mojem "zelniku". Vseeno najlepša hvala.

Zgodovina sprememb…

  • spremenilo: invisable ()

technolog ::

Naloga je slabo definirana.

Sicer pa jo naredi brez regexa. Poberi vse številke, vzemi samo zadnjih 8, pa jih razcepi v skupine 2,3,3.

invisable ::

V pravi txt datoteki so spredaj tudi presledki (dva primera). Drugače bi jo tudi jaz rešila brez dodatnih problemov, ampak je obvezno nalogo rešiti, s pomočjo njih.

Spura ::

invisable je izjavil:


Moja rešitev je tako:
[+386]?

I don't think this does what you think it does.

invisable ::

0?0?[ |\+]386?|[ \(]?\(?0\)?(\d{2})[\)\. / -]?[\)\. / -]?(\d{3})[\. -]?(\d{3})|

tudi tko ne gre...

še vedno se zatakne pri primeru 031 98 76 54..

Spura ::

invisable je izjavil:

0?0?[ |\+]386?

tudi tko ne gre...

še vedno se zatakne pri primeru 031 98 76 54..

Tole je se vedno komplet narobe.
Tole ti bo matchal:
+38
 38
 386
+386
\38
|38
|386
\386
0 38
00 38
0\38
0|386
itd...

Se mi zdi da niti ne poskusas razumet ampak pac tolces razlicne variante, dokler ti ena ne bo uspela.

invisable ::

Do sem sem prišla.. večinoma dela.. in mislim da je to tudi najbolj pravilna varianta... ampak +386 ali 00386 ne vem kako naj zapakiram skupaj.. mogoče bi morala uporabiti ali.. ampak ne vem kako se uporablja.. naj bi se postavil med () vendar bi s tem označila tudi skupino mar ni res? imam probleme, ker smo regularnim izrazom namenili le pol ure predavanja. In sama nisem ravno neke vrste programer, saj tudi ne hodim na FRI ali kakšno podobno šolo. Iskala sem tudi na ostalih forumih, ampak nikjer nisem zasledila kakšnega podobnega primera.


Ta del mi je popolnoma jasen:
^.*?\s*\(?0([0-9]{2})\)?[-. /]?([0-9]{3})[-. ]?([0-9]{3})$

ZA +386 pa ne vem kaj naresti...
ne vem zakaj mi v RX toolkitu ne obarva tudi tega izraza:
040/555999

031 98 76 54-tega mi ne obarva ker sta po dve in dve cifri skupaj
+386 (0)70 111 222- tega pa zaradi zgoraj omenjenega problema s +386

Ja sicer pa imaš prav, probavam, če mi rata.. ker sem že na koncu obupa s to nalogo.. saj sem jo uleraj reševala več kot 5 ur:S

invisable ::

TO sedaj dela za vse primere, razen za 031 98 76 54. Vsak nasvet bi bil dobrodošel. hvala=))
^(?:(?:00\s+)?[+( )]?(?:386 |s*)\(?0\)?(\d{2})[)./-]?\s*(\d{3})[./-]?\s*(\d{3})$

technolog ::

Glede tega sem ti že povedal, kako stvari stojijo, pa se ti na da brat.

Yacked2 ::

Kaj pa sploh želiš narediti ?

Iz vhodnega niza poberi samo cifre. Nato pa uzami zadnjih 8, spredaj pa napiši 0 pa imaš.
Korak naprej ni vedno ustrezen...sploh če si na robu prepada!

Yacked2 ::

Resitev javi:
String number =  " (051) 951-159";
		
		char[] resitev = new char[9];
		resitev[0] = '0';
		
		int n =8;
		for(int i =number.length()-1; i >= 0;i--)
		{
			if (n > 0)
			{
			char c = number.charAt(i);
			
			if(c=='0' || c=='1' || c=='2' || c=='3' || c=='4' || c=='5' || c=='6' || c=='7' || c=='8' || c=='9')
			{
				resitev[n] = c;
				n--;
			}
			}
		}
		String b = new String(resitev);
		
		System.out.println(b);


Če prav razumem mora iz niza razbrati 9 mesto številko.
Korak naprej ni vedno ustrezen...sploh če si na robu prepada!

jype ::

Jaz bi naredil takole:
cifra = cifra.replace('+', '00') # country code prefix
cifra = cifra.replace('(0)', '') # area code prefix
cifra = ''.join(re.findall(r'[0-9]', cifra)) # just digits
cifra = cifra.replace('00386', '0') # replace country code prefix and code with area code prefix
if cifra.startswith('00'): # should not happen but +386 0xx is illegal and still part of input
  cifra = cifra[1:]

Zgodovina sprememb…

  • spremenilo: jype ()

invisable ::

Zgornji izraz je pravilen samo prvi (:? Je odvec, sem se na zalist zmotila pri kopiranju...
Pri testnih primerih so spredaj obcasno se presledki.. Nalogo pa moram nujno resiti s pomocjo regularnih izrazov, drugace se ne bo upostevala...

Zgornjo kodo mi je potrdil tudi profesor in je rekel da je ze izoblikovana na taksen nacin kot pricakuje on ampak da ji moram dodati se elemente za primer ko so cifre po 2 skupaj in ne po 3... Jype najlepsa ti hvala.. Ampak mi resitev zal ne pomaga...

Drugace pa zelim izbrati skupaj zbrati stevilke in juh zapisati v drugi obliki.. Torej zberem 2,3 4-6 7,9 in naredim univerzalno obliko 0AA-BBB\CCC za vse stevilke...

Zgodovina sprememb…

  • spremenilo: invisable ()

NejcSSD ::

Živjo imam probleme pri simulacije igre Spomin v pythonu. Zelo bi bil hvaležen, če mi lahko kako pomagate:

Sestavi funkcijo, ki premeša karte, to je sestavi naključen seznam dolžine 2n, v katerem vsako število od 1 do n nastopa natanko dvakrat.

import random

def premešaj(n):
seznam = [] #ustvarili bomo naključen seznam dolžine 2n
for karta in range(1,n+1):
seznam+=2*[karta] #vsaka karta nastopa dvakrat
#naključno premešamo
random.shuffle(seznam)
return seznam

To sem naredil, zdaj pa rabim naslednje:

# Pri izbiri kart upoštevaj, da ima računalnik popoln spomin. Če je torej
# v prejšnjih poskusih že naletel na dve enaki karti, ju izbere in obdrži.
# Sicer med neodkritimi kartami naključno izbere prvo, nato pa spet odkrije par,
# če je na enako karto že naletel, ali pa tudi drugo karto izbere naključno.
# Pomagaš si lahko s pomožnimi seznami, v katerih beležiš,
# katere karte so še na mizi, katere karte so bile že odkrite
# (in nato spet skrite), ...


def popolnSpomin(n):
seznam = premešaj(n) #Karte premešamo
indeksiKart = [i+1 for i,seznam[i] in enumerate(seznam)] #Ustvarimo indekse kart
štKorakov = 0
žePoznamo = []
šeNePoznamo = indeksiKart[:]
#Ko bo seznam indeksov izpraznjen, je računalnik našel vse pare.
while len(indeksiKart) != 0 :

brezPrve = indeksiKart[:] #Ta seznam potrebujemo, da izločimo prvi izbor pred začetkom drugega izbora
štPrveKarte = random.choice(indeksiKart)
prvaKarta = seznam[štPrveKarte - 1] #ker gredo indeksiKart od 1 naprej
brezPrve.remove(štPrveKarte) #izločimo prvi izbor pred začetkom drugega izbora

drugaKarta = False #Jo pred preverjanjem ne poznamo.

for element in range(len(žePoznamo)): #preverimo seznam žePoznamo
štPoznaneKarte = žePoznamo[element]
if seznam[štPoznaneKarte-1] == prvaKarta and štPoznaneKarte != štPrveKarte:
poznamo = štPoznaneKarte
drugaKarta = True #Torej jo poznamo

#V vsakem koraku preverimo, če je karta že v seznamu poznanih, če ni, jo dodamo.
if štPrveKarte in žePoznamo:
pass
else:
žePoznamo.append(štPrveKarte)

if drugaKarta : #Potem poznamo par od 1.karte
štDrugeKarte = poznamo
drugaKarta = seznam[štDrugeKarte -1]

else: #Če 2. para še nismo srečali, potem izberemo naključno iz seznama brezPrve
štDrugeKarte = random.choice(brezPrve)
drugaKarta = seznam[štDrugeKarte -1]

# Oba izbora kart sedaj poznamo, in če je kakšna od njih še v seznamu šeNePoznamo,jo odstranimo
if štPrveKarte in šeNePoznamo:
šeNePoznamo.remove(štPrveKarte)
else:
pass

if štDrugeKarte in šeNePoznamo:
šeNePoznamo.remove(štDrugeKarte)
else:
pass

#Tako kot za prvo karto, naredimo še za drugo.
#V vsakem koraku preverimo, če je karta že v seznamu poznanih, če ni, jo dodamo.
if štDrugeKarte in žePoznamo:
pass
else:
žePoznamo.append(štDrugeKarte)

štKorakov +=1

if prvaKarta == drugaKarta:
#Če sta karti par, potem ju ustrezno odstranimo iz seznamov žePoznamo in indeksiKart, ker jih ne potrebujemo več.
žePoznamo.remove(štPrveKarte)
žePoznamo.remove(štDrugeKarte)
indeksiKart.remove(štPrveKarte)
indeksiKart.remove(štDrugeKarte)
print(štKorakov," - Izbrani karti #",štPrveKarte," (",prvaKarta,") in #",štDrugeKarte," (",drugaKarta,") STA par",sep="")

else:
#Če pa nista par, potem karti zakrijemo nazaj.
brezPrve.append(štPrveKarte) #če ni bilo para, potem nazaj dodamo indeks prve izvlečene karte, ker smo indeks prve karte
#pred izborom druge odstranili.
print(štKorakov," - Izbrani karti #",štPrveKarte," (",prvaKarta,") in #",štDrugeKarte," (",drugaKarta,") NISTA par",sep="")

Problem pa se pojavi, da dobim nekoliko preveč korakov in sicer zarad tega, ker bi moral prvo karto poklicati naključno, če morda nimam že para v seznamu že poznanih.
Link :


Recimo v 3. koraku bi že moral poklicati karti, ker sta že 2 isti med poznanimi.


Še link do python datoteke:
https://www.dropbox.com/s/7j2i0cd32k7l7...
PC : Asus P8Z68-V, i5-2500K, 8GB DDR3, MX100 256GB, Win10
OFFICE PC: Q1900-ITX, 4GB DDR3, Samsung 830 128GB, Win10
MAC: Apple Macbook Air 13,3" Mid 2013 , i5, 128Gb SSD, HD5000, 4Gb

jype ::

invisable> Zgornjo kodo mi je potrdil tudi profesor in je rekel da je ze izoblikovana na taksen nacin kot pricakuje on ampak da ji moram dodati se elemente za primer ko so cifre po 2 skupaj in ne po 3... Jype najlepsa ti hvala.. Ampak mi resitev zal ne pomaga...

Razumem. Škoda, da je šolski sistem še vedno tak, da ne zna nagraditi iznajdljivosti.

ragezor ::

mogoce pa jo hocejo nauciti regularne izraze in ne iznajdljivosti?

NejcSSD, ti pa lepse dostavi kodo, ker tega ne bo nihce bral
ko hoces prilepiti delcek kode, to naredis tako:
<pre class="brush:c">
#koda
</pre>

Zgodovina sprememb…

  • spremenil: ragezor ()

jype ::

ragezor> mogoce pa jo hocejo nauciti regularne izraze in ne iznajdljivosti?

Mogoče bi se potem morali potruditi sestaviti nalogo, ki jo je dejansko smiselno reševati z regularnimi izrazi.

ragezor> uporabi http://pastebin.com

ali pa uporabi oznako [st.koda]koda[/st.koda]

Zgodovina sprememb…

  • spremenilo: jype ()

ragezor ::

nevem, ce sem stisnil preklici pri editanju posta ali sem pa pokvaril celoten post in mi ni shranilo popravka...

torej..
@nejcSSD
uporabljaj st.koda znacko, za zacetek pa zmeci ven sumnike iz kode

pa tale vrstica takoj na zacetku je cudna:
indeksiKart = [i+1 for i,seznam[i] in enumerate(seznam)]


zakaj pristevas +1 k indeksu? kaj vraca enumerate funkcija? ima seznam[i] kaksen smisel? a bi bila kaka razlika ce bi uporabil [i for i in range(1,len(seznam)+1] ?

Zgodovina sprememb…

  • spremenil: ragezor ()

NejcSSD ::

##################################################################################
# Igro Spomin igramo z 2n kartami, na katerih je narisanih n različnih sličic
#(vsaka sličica je narisana na natanko dveh kartah). Karte položimo na mizo
#(ne na kup, pač pa vsako zase) s sličicami navzdol, jih premešamo, nato pa
#igralci izmenično izbirajo po dve karti. Igralec izbrani karti odkrije in
#sličici pokaže soigralcem. Če sta sličici na izbranih kartah enaki, igralec
#karti obdrži, sicer pa ju spet obrne. Zmaga igralec, ki zbere največ kart.
#Igro lahko igra več igralcev ali pa z njo trenira svoj spomin samo en igralec.
##################################################################################

import random

def premešaj(n): 
    seznam = [] #ustvarili bomo naključen seznam dolžine 2n
    for karta in range(1,n+1):
        seznam+=2*[karta] #vsaka karta nastopa dvakrat
    #naključno premešamo
    random.shuffle(seznam)
    return  seznam

# Pri izbiri kart upoštevaj, da ima računalnik popoln spomin. Če je torej
# v prejšnjih poskusih že naletel na dve enaki karti, ju izbere in obdrži.
# Sicer med neodkritimi kartami naključno izbere prvo, nato pa spet odkrije par,
# če je na enako karto že naletel, ali pa tudi drugo karto izbere naključno.
# Pomagaš si lahko s pomožnimi seznami, v katerih beležiš,
# katere karte so še na mizi, katere karte so bile že odkrite
# (in nato spet skrite), ... 
#
##################################################################################

def popolnSpomin(n):
    seznam = premešaj(n) #Karte premešamo
    indeksiKart = [i+1 for i in range(2*n)] #Ustvarimo indekse kart
    štKorakov = 0
    žePoznamo = []
    šeNePoznamo = indeksiKart[:]
    #Ko bo seznam indeksov izpraznjen, je računalnik našel vse pare.
    while len(indeksiKart) != 0 :
        print(" -----------")
        brezPrve = indeksiKart[:]  #Ta seznam potrebujemo, da izločimo prvi izbor pred začetkom drugega izbora
        štPrveKarte = random.choice(indeksiKart)
        prvaKarta = seznam[štPrveKarte - 1] #ker gredo indeksiKart od 1 naprej
        brezPrve.remove(štPrveKarte) #izločimo prvi izbor pred začetkom drugega izbora
        drugaKarta = False  #Jo pred preverjanjem ne poznamo.
        for element in range(len(žePoznamo)): #preverimo seznam žePoznamo
            štPoznaneKarte = žePoznamo[element]
            if seznam[štPoznaneKarte-1] == prvaKarta and štPoznaneKarte != štPrveKarte:
                poznamo = štPoznaneKarte
                drugaKarta = True #Torej jo poznamo

        #V vsakem koraku preverimo, če je karta že v seznamu poznanih, če ni, jo dodamo.   
        if štPrveKarte in žePoznamo:
            pass
        else:
            žePoznamo.append(štPrveKarte)
            
        if drugaKarta : #Potem poznamo par od 1.karte
            štDrugeKarte = poznamo
            drugaKarta = seznam[štDrugeKarte -1]
    
        else: #Če 2. para še nismo srečali, potem izberemo naključno iz seznama brezPrve
            štDrugeKarte = random.choice(brezPrve)
            drugaKarta = seznam[štDrugeKarte -1]

        # Oba izbora kart sedaj poznamo, in če je kakšna od njih še v seznamu šeNePoznamo,jo odstranimo
        if štPrveKarte in šeNePoznamo:
            šeNePoznamo.remove(štPrveKarte)
        else:
            pass
        
        if štDrugeKarte in šeNePoznamo:
            šeNePoznamo.remove(štDrugeKarte)
        else:
            pass
            
        #Tako kot za prvo karto, naredimo še za drugo.
        #V vsakem koraku preverimo, če je karta že v seznamu poznanih, če ni, jo dodamo.
        if štDrugeKarte in žePoznamo:
            pass
        else:
            žePoznamo.append(štDrugeKarte)
         
        štKorakov +=1
        
        if prvaKarta == drugaKarta:
            #Če sta karti par, potem ju ustrezno odstranimo iz seznamov žePoznamo in indeksiKart, ker jih ne potrebujemo več.
            žePoznamo.remove(štPrveKarte)
            žePoznamo.remove(štDrugeKarte)
            indeksiKart.remove(štPrveKarte)
            indeksiKart.remove(štDrugeKarte)
            print(štKorakov," - Izbrani karti #",štPrveKarte," (",prvaKarta,") in #",štDrugeKarte," (",drugaKarta,") STA par",sep="")
        
        else:
            #Če pa nista par, potem karti zakrijemo nazaj.
            brezPrve.append(štPrveKarte) #če ni bilo para, potem nazaj dodamo indeks prve izvlečene karte, ker smo indeks prve karte
                                         #pred izborom druge odstranili.
            print(štKorakov," - Izbrani karti #",štPrveKarte," (",prvaKarta,") in #",štDrugeKarte," (",drugaKarta,") NISTA par",sep="")
        
        


        
        
        print(" -----------")

PC : Asus P8Z68-V, i5-2500K, 8GB DDR3, MX100 256GB, Win10
OFFICE PC: Q1900-ITX, 4GB DDR3, Samsung 830 128GB, Win10
MAC: Apple Macbook Air 13,3" Mid 2013 , i5, 128Gb SSD, HD5000, 4Gb

Math Freak ::

Jaz bi popravke delal na teh mestih:

##################################################################################
# Igro Spomin igramo z 2n kartami, na katerih je narisanih n različnih sličic
#(vsaka sličica je narisana na natanko dveh kartah). Karte položimo na mizo
#(ne na kup, pač pa vsako zase) s sličicami navzdol, jih premešamo, nato pa
#igralci izmenično izbirajo po dve karti. Igralec izbrani karti odkrije in
#sličici pokaže soigralcem. Če sta sličici na izbranih kartah enaki, igralec
#karti obdrži, sicer pa ju spet obrne. Zmaga igralec, ki zbere največ kart.
#Igro lahko igra več igralcev ali pa z njo trenira svoj spomin samo en igralec.
##################################################################################
 
import random
 
def premešaj(n): 
    seznam = [] #ustvarili bomo naključen seznam dolžine 2n
    for karta in range(1,n+1):
        seznam+=2*[karta] #vsaka karta nastopa dvakrat
    #naključno premešamo
    random.shuffle(seznam)
    return  seznam
 
# Pri izbiri kart upoštevaj, da ima računalnik popoln spomin. Če je torej
# v prejšnjih poskusih že naletel na dve enaki karti, ju izbere in obdrži.
# Sicer med neodkritimi kartami naključno izbere prvo, nato pa spet odkrije par,
# če je na enako karto že naletel, ali pa tudi drugo karto izbere naključno.
# Pomagaš si lahko s pomožnimi seznami, v katerih beležiš,
# katere karte so še na mizi, katere karte so bile že odkrite
# (in nato spet skrite), ... 
#
##################################################################################
 
def popolnSpomin(n):
    seznam = premešaj(n) #Karte premešamo
    indeksiKart = [i+1 for i in range(2*n)] #Ustvarimo indekse kart
    štKorakov = 0
    žePoznamo = []
    šeNePoznamo = indeksiKart[:]

    #Ko bo seznam indeksov izpraznjen, je računalnik našel vse pare.
    while len(indeksiKart) != 0 :

# DODATEK # 
        st = 0
        #Najprej preverimo, če poznamo že dve enaki karti, torej če je druga odkrita karta že v seznamu poznanih
        for karta in žePoznamo:
            if seznam[karta-1] == seznam[štDrugeKarte-1]:
                st += 1
        if st == 2:   
            print("poznamo že dva para - odkrij ju")
            break
# /DODATEK #

        else:
            print(" -----------")
            brezPrve = indeksiKart[:]  #Ta seznam potrebujemo, da izločimo prvi izbor pred začetkom drugega izbora

# POPRAVEK - vleči moramo iz nepoznanih kart #
            štPrveKarte = random.choice(šeNePoznamo)   
# /POPRAVEK #

            prvaKarta = seznam[štPrveKarte - 1] #ker gredo indeksiKart od 1 naprej
            brezPrve.remove(štPrveKarte) #izločimo prvi izbor pred začetkom drugega izbora
            drugaKarta = False  #Jo pred preverjanjem ne poznamo.

# SKRČITEV #
            for karta in žePoznamo: #preverimo seznam žePoznamo
                if seznam[karta-1] == prvaKarta and karta != štPrveKarte:
                    poznamo = karta
                    drugaKarta = True #Torej jo poznamo
# /SKRČITEV #
     
            #V vsakem koraku preverimo, če je karta že v seznamu poznanih, če ni, jo dodamo.   
            if štPrveKarte not in žePoznamo:
                žePoznamo.append(štPrveKarte)
                 
            if drugaKarta is True: #Potem poznamo par od 1.karte
                štDrugeKarte = poznamo
                drugaKarta = seznam[štDrugeKarte -1]
         
            else: #Če 2. para še nismo srečali, potem izberemo naključno iz seznama brezPrve
                
# POPRAVEK - vleči moramo iz nepoznanih kart #
                štDrugeKarte = random.choice(šeNePoznamo)
# /POPRAVEK#             
                drugaKarta = seznam[štDrugeKarte -1]
     
            #Oba izbora kart sedaj poznamo, in če je kakšna od njih še v seznamu šeNePoznamo,jo odstranimo
            if štPrveKarte in šeNePoznamo:
                šeNePoznamo.remove(štPrveKarte)
             
            if štDrugeKarte in šeNePoznamo:
                šeNePoznamo.remove(štDrugeKarte)
                 
            #Tako kot za prvo karto, naredimo še za drugo.
            #V vsakem koraku preverimo, če je karta že v seznamu poznanih, če ni, jo dodamo.
            if štDrugeKarte not in žePoznamo:
                žePoznamo.append(štDrugeKarte)
              
            štKorakov +=1
             
            if prvaKarta == drugaKarta:
                #Če sta karti par, potem ju ustrezno odstranimo iz seznamov žePoznamo in indeksiKart, ker jih ne potrebujemo več.
                žePoznamo.remove(štPrveKarte)
                žePoznamo.remove(štDrugeKarte)
                indeksiKart.remove(štPrveKarte)
                indeksiKart.remove(štDrugeKarte)
                print(štKorakov," - Izbrani karti #",štPrveKarte," (",prvaKarta,") in #",štDrugeKarte," (",drugaKarta,") STA par",sep="")
             
            else:
                #Če pa nista par, potem karti zakrijemo nazaj.
                brezPrve.append(štPrveKarte) #če ni bilo para, potem nazaj dodamo indeks prve izvlečene karte, ker smo indeks prve karte
                                             #pred izborom druge odstranili.
                print(štKorakov," - Izbrani karti #",štPrveKarte," (",prvaKarta,") in #",štDrugeKarte," (",drugaKarta,") NISTA par",sep="")
         
popolnSpomin(7)

ragezor ::

jaz bi spomin naredil tako (predpostavljam, da se ne poznas drugih podatkovnih struktur kot seznam):
mas 10 kart recimo v spremenljivki karte, to pomeni da so karte oznacene od 0 do 4
potem mas en prazen seznam seznamov, ki ti belezi indekse na katerih so karte in en seznam kjer mas zapisane indekse.

karte = [k for k in range(5)] * 2
random.shuffle(karte)
racunalnikov_spomin = [ [] for i in range(5)]
indeksi = [i for i in range(len(karte)]

torej racunalnikov_spomin vsebuje 5 seznamov. seznam 0 belezi indekse kje je karta z vrednostjo 0. notranji seznam na poziciji 3 pa belezi indekse kje sta karti z vrednstjo 3. ce imamo 2 indeksa v katerem od teh notranjih seznamov smo nasli par.
potem si pa zberes en
indeks = random.choose(indeksi)
in ga izbrises iz indeksov, da ga ne bos naslednjic spet odpiral indeksi.remove(indeks)
pogledas v karte kaka vednost je na tem indeksu in si shranis indeks v racunalnikov spomin:
racunalnikov_spomin[karte[indeks]].append(indeks)

potem pogledas ce je v racunalnikovem spominu dolzina dva, to pomeni da si za vrednost karte nasel oba indeksa, kjer se karti z to vrednostjo nahajata in odpres drugi indeks. ce ti je uspelo najti si nekje zabelezis, da si nasel obe karti, da bos vedel kdaj koncati igro.

ce notranji seznam ni dolzine dva, odpres nov random indeks, si ga shranis v racunalnikov spomin, glede na vrednost, ki je pod tem indeksom in spet preveris ce je notranji seznam dolzine dva. ce je dolzine dva, potem anslednjo rundo odpres ta dva indeksa. ce ni dolzine dva, dalje nakljucno odpiras indekse, dokler ne najdes vseh kart.

evo to je to na hitro

Zgodovina sprememb…

  • spremenil: ragezor ()


Vredno ogleda ...

TemaSporočilaOglediZadnje sporočilo
TemaSporočilaOglediZadnje sporočilo
»

Blackjack v igralnici

Oddelek: Loža
153287 (896) MonoPattern
»

zemljevid brez kompasa

Oddelek: Mobilne tehnologije
6511 (438) one too many
»

[C#] Domača naloga - osnove

Oddelek: Programiranje
371566 (783) 11tomi12
»

Šnops igra za PC ?

Oddelek: Igre
4722753 (17571) BOCo.
»

Klondike (strani: 1 2 )

Oddelek: Programiranje
583342 (2684) Thomas

Več podobnih tem