codez

1. Pats svarīgākais SEO ir saturs, tā unikalitāte un dažādība. SEO eksperts drīzāk būs nevis programmētājs, bet cilvēks, kurš orientējas SEO lietās, izpēta konkrētā brenda pārstāvētā tirgus stāvokli Googlē, kādi ir galvenie atslēgas vārdi, cik labas lapas un kādiem vārdiem jau ir kādās pozīcijās un pirmais ir mēģināt saprast, kādu unikālu un daudzveidīgu saturu ievietojot, varēs nokļūt meklētāja pirmajā lapā arī bez liela PR kāpuma. Piemēram, tev ir autoserviss Mārupē, tad ir jādomā kā cilvēki varētu meklēt šo servisu, viņi vārētu ievietot vietas nosaukumus: Mārupe, Lidostas tuvumā, galveno ielu nosaukumus, utt. Viņi varētu norādīt specifiskas mašīnu markas, viņi varētu norādīt specifiskus defektus. Var izveidot rakstu sērīju, kurā ir aprakstīts kā kopt mašīnu, kā uzturēt kārtība, kas kad ir jāmaina un vienlaikus attēlot šos rakstus ar īsu kompānijas atrašanās vietas datu paneli, lai šie, piemēram, vārdi: "motora defekts serviss Mārupe Daugavas iela audi" būtu vienā lapā un dažādas šo vārdu kombinācijas būtu unikālas visā internetā. Tāpēc aizpildot lapu ar šādu saturu, kur lapās parādās vietas, detalizētāki pakalpojuma aspekti, utt., var iegūt nozīmīgu apmeklētāju skaitu no Googles. Vēl viens veids kā radīt unikālu saturu, ir lietotāju radīts saturs. Piemēram tāds autoserviss varētu izveidot jautājumu sadaļu, kurā cilvēki var jautāt ekspertam un publicēt šos jautājumus un atbildes, utml. Šādu pieeju var atrast gandrīz katra veida lapām. Un cilvēks, kurš spēj izveidot šādas lapas uzbūves un satura struktūru, vadoties pēc šiem principiem, arī var sevi saukt par SEO ekspertu. Un varbūt ne tikai vienreiz izveido visu, bet strādā sadarbojoties ar konkrēto brendu gadus, analizējot analītikas datus, skatoties kādi atslēgas vārdi dod labumu, kādi ir lieki, kuros konkurēt nav iespējams, utt. 2. Otra no svarīgākajām lietām ir dublēts saturs, respektīvi, tā neesamība. Ir svarīgi, lai viena un tā pati lapa netiktu attēlota ar 100 dažādiem linkiem, un galvenais, lai šie dažādie linki un šīm viena satura lapām nevestu no citām lapām. Jo PR ir ne tikai visai lapai kopumā, bet katrai atsevišķai un tādā veidā tas tiek sadalīts un zaudēts dublētā satura lapās. Vislabākais variants ir palaist kādu labu kravleri uz savu lapu un paskatīties, cik tad unikālu lapu šis atrod un mēģināt likvidēt dublikātus. Protams googlei ir kaut kāda veida dublētā satura atpazīšana, bet arī tādā gadījumā dublētais saturs rada ļaunumu, jo google kravlē tavu domeinu ar noteiktu intensitāti un dublētais saturs var krietni ierobežot piekļūšanu unikālam saturam. Ar dublikātiem šeit es domāju, piemēram: - dažādi search rezultāti, kuros rezultātu lapās ir viens un tas pats, piemēram, /search?q=auto, /search?=mašīna, /search?q=auto&order=desc, utml. - viena un tā pati lapa ar dažādiem linkiem: /article/123, /article/123-kas-jauns, /article/123?ref=something, /article/123-kas-jauns?ref=something. Šeit var neobligāti parametri radīt kombināciju saišu, kas ved uz vienu un to pašu lapu. Tie var būt kaut kādi papildinājumi saitei, analītikas dati, u.c. parametri. 3. Google kravleris jau labu laiku izpilda javascriptu.

Pietika, būtībā mans vispārīgais risinājums jau ir pareizs.

javascripts pēc fellony algoritma; https://jsfiddle.net/69z2wepo/6799/ var X = x => x.match(/.{2,2}/g).filter(e=>e[0]!=e[1]).map(e=>e[0])

Pēc tavas loģikas, tavu uzdevumu var reducēt līdz uzdevumam: "Uzrakstiet funkciju X, kas izvada fellony iedomātu skaitli." Ja uzskati, ka tā nav, tad pasaki, kāpēc tieši tavs risinājums ir pareizs, bet, piemēram, mans vai martins256 nav?

Es netrollēju, tev jāiemācās pareizi formulēt uzdevumus. Un uzdevumā nav neviens punkts, kurš nosaka, ka rezultāta sekvences nedrīkst būt vienādas. Vēl vairāk, arī tavs algoritms uz dažām dažādām sekvencēm dos vienādu izvadi. Martins256 algoritms ir implementēts (a) un viņš nosaka 2. sekvences rezultātu (b) un šis rezultāts nav pretrunā ar nevienu uzdevuma nosacījumu. Es ceru, ka tu saproti, ka tavam uzdevumam ir bezgalīgi daudz dažādu risinājumu.

Uzdevumā nav norādīti nekādi noteikumi kādam jābūt izvades rezultātam, kā tikai piemērs. Martins256 funkcija atgriež pareizu piemēru un tālāk nepārkāpj nevienu uzdevuma nosacījumu. Martins256 funkcija viennozīmīgi atbilst pareiza uzdevuma atbildei.

Kuru tieši no uzdevuma nosacījumiem pārkāpj martins256 kods?

Man uz Kubuntu Gwenview varēja atvērt apskatei to .psd.

Jā, tā ir pareizā atbilde.

Pēc uzdevuma nosacījumiem, pareiza atbilde ir jebkura funkcija, kura atgriež piemēra atbildi, tā kā citu nosacījumu nav. Uzdevumu varētu piemēram padarīt par kompetatīvu, teiksim nosakot uzvarētāju pēc īsākā koda un dodot vismaz vairākus piemērus, lai vienkārša piemēra izvades atgriešana nebūtu pareiza.

Labāk sāc lietot reactjs, kāpēc sākt lietot novecojušus FW?

Tāpat kā pirmajā. Pirmajā sākumā noņem visus reizinājumus, kas ir pa vienam, pēc tam visas summas. Otrajā iterācijā atkal būs jauni reizinājumi, kuri ir par vienam, jo iepriekš noņemot summas tādi varēja rasties.

Uzdevums patiesībā nav grūts. Uzģenerējam visus iespējamos variantus, kopā ar to summām un reizinājumiem. Ja sākumā Jānis nezin, tas nozīmē, ka ir viņa reizinājums ir vairākas reizes starp iespējamajiem variantiem. Sagrupējam visus variantus pēc reizinājuma un atlasām to, kuri ir vairāk kā 1 reizi. To pašu dara ar summām, atlasa tās, kuras ir vairāk kā vienu reizi. Pēdējos 2 soļus dara 7 reizes. Tālāk, ja Jānis zin atbildi, tas nozīmē, ka šajā brīdī eksistē viens variants ar unikālu reizinājumu, kas arī ir atbilde. Kurš tiks pie atbildes?

Kaut arī funkcija garāka kā martins256, tomēr:

Daudzas lietas ir pluginojamas vai modulāras, tāpēc vari izstrādāt pilnīgi neatkarīgi moduli vai pluginu.

Šādi tavuprāt ir pietiekami verbozi: https://ideone.com/7qA0cJ ? object Main extends App { case class State(a: Int, b: Int, sum:Int, mul:Int) val allPossibleStates:Seq[State] = for { i <- 2 to 99; j <- i to 99 } yield State(i,j,i+j,i*j) //Atlasām kopu ar visiem reizinājumiem, kuri ir iespējami - iegūstami vismaz 2 veidos val allPossibleMultiplications:Set[Int] = allPossibleStates .groupBy(_.mul) .collect{ case (key, seq) if seq.size >= 2 => key} .toSet //Tā kā Pēteris zināja, ka Jānis nezin, tad iespējami ir tikai tie varianti, //kuru summas var sadalīt saskaitāmajos, kuru reizinājumi ir iegūstami vismaz 2 veidos val petersStates:Seq[State] = allPossibleStates .groupBy(_.sum) .collect{case (key, seq) if seq.forall { el => allPossibleMultiplications.contains(el.mul) } => seq} .flatten .toSeq //Tā kā Jānis tagad zin atbildi, tas nozīmē, ka derīgi ir tikai tie stāvokļi, //kuros reizinājumu var iegūt tikai vienā veidā. val allPossibleStatesWhenJohnKnows:Seq[State] = petersStates .groupBy(_.mul) .collect{case (key, seq) if seq.size==1 => seq} .flatten .toSeq //Tā kā Pēteris tagad zin atbildi, tas nozīmē, ka derīgi ir tikai tie stāvokļi, //kuros summu var iegūt tikai vienā veidā. val allPossibleStatesWhenPeterKnows:Seq[State] = allPossibleStatesWhenJohnKnows .groupBy(_.sum) .collect{case (key, seq) if seq.size==1 => seq} .flatten .toSeq println(allPossibleStatesWhenPeterKnows) }

Lūk tev tik pat "nesaprotams" kods: https://github.com/php/php-src/blob/master/ext/hash/hash_sha.c#L790 Ja tu negribi vai nevari iedziļināties algoritma būtībā, tad arī kods tev būs nesaprotams. Sarežģītiem algoritmiem kods nekad nebūs pašdokumentējošs un vispirms būs jāsaprot algoritms. Protams, ka es varēju kodu rakstīt nevis funkcionālā stilā, bet imperatīvā, lai tiem, kam nav ierasti funkcionālās programmēšanas paterni, tas būtu saprotamāks. Bet varbūt tomēr iemācīties, ko dara funkcijas groupBy, collect, map, filter, flatMap, utml? Visu ar karoti nevaru ieliet.

Uzdevums nav no vieglajiem, tāpēc tev tā šķiet. Nekas, tā nav bēda, ar laiku nāks tev pieredze un iemācīsies lasīt arī sarežģītāku kodu. Tas ir tāpat kā ne katrs spēj lasīt, piemēram, Kanta darbus.

Risinot šo uzdevumu izdomāju interesantu variantu. Ir 2 skaitļi no 1 līdz 99, Jānim pasaka skaitļu reizinājumu, bet Pēterim summu. Starp viņiem norisinās šāds dialogs: J: Es nezinu šos skaitļus P: Es nezinu šos skaitļus J: Es nezinu šos skaitļus P: Es nezinu šos skaitļus J: Es nezinu šos skaitļus P: Es nezinu šos skaitļus J: Es nezinu šos skaitļus P: Es nezinu šos skaitļus J: Es nezinu šos skaitļus P: Es nezinu šos skaitļus J: Es nezinu šos skaitļus P: Es nezinu šos skaitļus J: Es nezinu šos skaitļus P: Es nezinu šos skaitļus J: Tagad es zinu šos skaitļus Kādi ir šie skaitļi?

php newbie algoritma variants Scalā: https://ideone.com/hp1xHw object Main extends App { val A = for (i <- 2 to 99; j <- i to 99) yield ((i, j, i + j, i * j)) val B = A.groupBy(_._4).filter(_._2.size >= 2) A.groupBy(_._3).filter(_._2.forall(e=>B.contains(e._4))).flatMap(_._2) .groupBy(_._4).filter(_._2.toList.size==1).flatMap(_._2) .groupBy(_._3).filter(_._2.toList.size==1).flatMap(_._2) .map(println) }

Izņemot nedaudz liekās lietas: https://ideone.com/ixvy5b object Main extends App { def fc(n:Int, i:Int = 2):Int = if (i*i>n) 0 else if (n%i==0) fc(n/i,i)+1 else fc(n,i+1) val set=(4 to 196).filter(n => (2 to n/2).map(k => fc(k*(n-k))).min>=2).toSet def fp(n :Int, i:Int = 2):List[(Int,Int)] = if (i*i>n) Nil else if (n%i==0 && set.contains(i+n/i)) (i,n/i) :: fp(n,i+1) else fp(n,i+1) val map=(4 to 99*99).map(fp(_)).filter(_.length==1).groupBy(el => el.head._1+el.head._2) println(map.filter(_._2.length==1).head._2(0)(0)) } P.S.: Vēl īsāk: https://ideone.com/pJ95mU object Main extends App { def fc(n:Int) = (2 to math.sqrt(n).toInt).filter(n%_==0).length val set=(4 to 196).filter(n => (2 to n/2).map(k => fc(k*(n-k))).min>=2).toSet (4 to 9999) .map(n => (2 to math.sqrt(n).toInt).collect{case i if (n%i==0 && set.contains(i+n/i)) => (i,n/i)}) .collect{case Seq(x) => x} .groupBy(el => el._1+el._2) .collect{case (x, Seq(h)) => println(h)} }

Risinājums scalā: https://ideone.com/tXJq1H 1. Kad Jānis pasaka, ka nezin tos skaitļus, tas nozīmē, ka Jāņa reizinājumu var sadalīt vismaz 2 vai vairāk reizinātājos, jo pretējā gadījumā Jānis uzreiz zinātu skaitļus (piemēram, ja Jānim būtu 35, tad viņš zinātu, ka tie ir 5*7). 2. Kad Pēteris pasaka, ka viņš to zin, tas nozīmē, ka Pētera summa ir sadalāma divos skaitļos tā, ka šo divu skaitļu reizinājums vienmēr sastāv no vairāk kā diviem reizinātājiem, lai izpildītos Jāņa pirmais apgalvojums, ka viņš nezin šos skaitļus. Attiecīgi Pētera summa var būt kāds no šiem skaitļiem: TreeSet(11, 17, 23, 27, 29, 35, 37, 41, 47, 51, 53, 57, 59, 65, 67, 71, 77, 79, 83, 87, 89, 93, 95, 97, 101, 107, 113, 117, 119, 121, 123, 125, 127, 131, 135, 137, 143, 145, 147, 149, 155, 157, 161, 163, 167, 171, 173, 177, 179, 185, 187, 189, 191) Šos skaitļus iegūstam ejot cauri visām summām, dalot visos iespējamos variantos un skatoties, vai reizinājumus var vienmēr sadalīt vairāk kā 2 reizinātājos.Piemēram, 11 var sadalīt kā 2+9, 3+8, 4+7, 5+6 un iegūt reizinājumus 18, 24, 28, 30, kuru nevienā no gadījumiem Jānis uzreiz nevar zināt divus sākotnējos skaitļus. 3. Kad Jānis pasaka, ka viņš zin šos skaitļus, tas nozīmē, ka viņa reizinājumu sadalot visos iespējamajos reizinātājos un to summējot, tikai viena no šīm summām drīkst būt kāda no Pētera summām. Attiecīgi ejam cauri visiem reizinājumiem, dalām reizinātājos a un b un summējam tos, atlasām visus tos reizinājumus, kuru reizinātāju summa tikai vienu reizi veido kādu no Pētera summām un sagrupējām visus šos reizinājumus to atbilstošajām summām. (11,Vector(18, 24, 28)) (17,Vector(52)) (23,Vector(76, 112)) (27,Vector(50, 92, 140, 152, 176)) (29,Vector(54, 100, 208)) (35,Vector(96, 124, 216, 304)) (37,Vector(160, 232, 336)) (41,Vector(148, 288, 400, 414, 418)) (47,Vector(172, 280, 442, 496)) (51,Vector(98, 144, 188, 308, 344, 494, 518, 578, 608, 620, 638, 644)) (53,Vector(430, 520, 592, 646, 672, 682)) Pārējais: Tā kā Jānis zin savu reizinājumu, tad šajā brīdī viņš var zināt arī Pētera summu un attiecīgi abus sākotnējos skaitļus. 4.Kad Pēteris pasaka, ka tad viņš arī zin, tas nozīmē, ka Pēterim ir tāda summa, kurai atbilstošs reizinājums veidojas tikai vienā veidā. Tagad arī mēs varam zināt, kura ir šī summa. Pēc datiem var redzēt, ka tikai summai 17 atbilst viens vienīgs reizinājums 52, kas nozīmē, ka skaitļi ir: 4 un 13. Kods: import scala.collection.immutable.SortedSet import scala.collection.immutable.SortedMap object Main extends App { def factors(n:Int):List[Int] = { def divides(d:Int, n:Int) = (n % d) == 0 def ld(n:Int):Int = ldf(2, n) def ldf(k:Int, n:Int):Int = { if (divides(k, n)) k else if ((k*k) > n) n else ldf((k+1), n) } n match { case 1 => Nil case _ => val p = ld(n); p :: factors(n / p) } } def allSums(n:Int):Seq[(Int,Int)] = { for (i <- 2 to n/2) yield (i, n-i) } def minMulFactorCount(s:Seq[(Int,Int)]) = { s.map{case (a,b) => factors(a*b).length}.min } val sumSet = SortedSet[Int]() ++ (4 to 196).filter(i => minMulFactorCount(allSums(i)) > 2) println(sumSet) def allPairFactors(n:Int) = { def rec(i:Int):List[(Int,Int)] = { if (i*i>n) Nil else if (n%i==0) (i,n/i)::rec(i+1) else rec(i+1) } rec(2) } val mulMap=SortedMap[Int, List[(Int,Int)]]() ++ (4 to 99*99) .map(allPairFactors(_).filter{case (a,b) => sumSet.contains(a+b)}) .filter(_.length==1) .map{ case el::Nil => (el._1+el._2, el._1 * el._2) case _ => (0,0) } .groupBy{case (a,b) => a} mulMap.foreach(el => { println(el._1, el._2.map(_._2)) }) }

To būs izdarīt legāli diezgan grūti. Maksāt autoratlīdzību ir pilnīgi legāli. Pie tam nesamaksāta pārsvarā tiek soc. nodokļa daļa. Un te ir jautājums, vai tu māki pats labāk menidžēt savas sociālās garantijas, vai labāk to uztici Valstij.