[Python] Domači nalogi

Ž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!

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()

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).

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.

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 :+}"
}

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 :+}"

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.

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 je 13. mar 2014 ob 20:10 izjavil:

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

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

invisable je 13. mar 2014 ob 21:07 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.

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})$

Kaj pa sploh želiš narediti ?

Iz vhodnega niza poberi samo cifre. Nato pa uzami zadnjih 8, spredaj pa napiši 0 pa imaš.

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:]

Ž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...

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>

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] ?

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)