Kelime sayma

HECELER = ["ka", "ba", "la", "ng", "ke", "li", "me", "de", "si", "ne", "ta", "ra", "mo", "du", "pi", "ze"]

# Belirli (her koşuda aynı) ~1 MB metin: 20.000 satır × 10 kelime.
x = 42
satirlar: liste<metin> = []
dongu _ icinde 0..<20000:
    kelimeler: liste<metin> = []
    dongu _ icinde 0..<10:
        x = (x * 1103515245 + 12345) % 2147483648
        hece_sayisi = x // 65536 % 3 + 1
        kelime = ""
        dongu _ icinde 0..<hece_sayisi:
            x = (x * 1103515245 + 12345) % 2147483648
            kelime += HECELER[x // 65536 % 16]
        kelimeler.ekle(kelime)
    satirlar.ekle(kelimeler.birlestir(" "))
metin = satirlar.birlestir("\n")

sayilar: sozluk<metin, sayi> = {}
toplam = 0
dongu satir icinde metin.bol("\n"):
    dongu kelime icinde satir.bol(" "):
        sayilar[kelime] = sayilar.al(kelime, 0) + 1
        toplam += 1

en_sik = ""
en_cok = 0
harf = 0
dongu kelime, adet icinde sayilar.ciftler():
    harf += kelime.uzunluk() * adet
    eger adet > en_cok veya (adet == en_cok ve kelime < en_sik):
        en_sik = kelime
        en_cok = adet

yazdir(metin.uzunluk(), toplam, sayilar.uzunluk(), en_sik, en_cok, harf)

#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

int main() {
    const std::vector<std::string> HECELER = {"ka", "ba", "la", "ng", "ke", "li", "me", "de",
                                              "si", "ne", "ta", "ra", "mo", "du", "pi", "ze"};

    // Belirli (her koşuda aynı) ~1 MB metin: 20.000 satır × 10 kelime.
    long long x = 42;
    std::string metin;
    for (int s = 0; s < 20000; ++s) {
        if (s) metin += '\n';
        for (int k = 0; k < 10; ++k) {
            x = (x * 1103515245 + 12345) % 2147483648LL;
            int hece_sayisi = x / 65536 % 3 + 1;
            std::string kelime;
            for (int h = 0; h < hece_sayisi; ++h) {
                x = (x * 1103515245 + 12345) % 2147483648LL;
                kelime += HECELER[x / 65536 % 16];
            }
            if (k) metin += ' ';
            metin += kelime;
        }
    }

    std::unordered_map<std::string, long long> sayilar;
    long long toplam = 0;
    size_t satir_bas = 0;
    while (satir_bas <= metin.size()) {
        size_t satir_son = metin.find('\n', satir_bas);
        if (satir_son == std::string::npos) satir_son = metin.size();
        size_t bas = satir_bas;
        while (true) {
            size_t son = metin.find(' ', bas);
            if (son == std::string::npos || son > satir_son) son = satir_son;
            ++sayilar[metin.substr(bas, son - bas)];
            ++toplam;
            if (son == satir_son) break;
            bas = son + 1;
        }
        satir_bas = satir_son + 1;
    }

    std::string en_sik;
    long long en_cok = 0, harf = 0;
    for (const auto &[kelime, adet] : sayilar) {
        harf += kelime.size() * adet;
        if (adet > en_cok || (adet == en_cok && kelime < en_sik)) {
            en_sik = kelime;
            en_cok = adet;
        }
    }

    std::cout << metin.size() << " " << toplam << " " << sayilar.size() << " " << en_sik << " " << en_cok << " "
              << harf << std::endl;
    return 0;
}

HECELER = ["ka", "ba", "la", "ng", "ke", "li", "me", "de", "si", "ne", "ta", "ra", "mo", "du", "pi", "ze"]

# Belirli (her koşuda aynı) ~1 MB metin: 20.000 satır × 10 kelime.
x = 42
satirlar = []
for _ in range(20000):
    kelimeler = []
    for _ in range(10):
        x = (x * 1103515245 + 12345) % 2147483648
        hece_sayisi = x // 65536 % 3 + 1
        kelime = ""
        for _ in range(hece_sayisi):
            x = (x * 1103515245 + 12345) % 2147483648
            kelime += HECELER[x // 65536 % 16]
        kelimeler.append(kelime)
    satirlar.append(" ".join(kelimeler))
metin = "\n".join(satirlar)

sayilar = {}
toplam = 0
for satir in metin.split("\n"):
    for kelime in satir.split(" "):
        sayilar[kelime] = sayilar.get(kelime, 0) + 1
        toplam += 1

en_sik = ""
en_cok = 0
harf = 0
for kelime, adet in sayilar.items():
    harf += len(kelime) * adet
    if adet > en_cok or (adet == en_cok and kelime < en_sik):
        en_sik = kelime
        en_cok = adet

print(len(metin), toplam, len(sayilar), en_sik, en_cok, harf)

const HECELER = ["ka", "ba", "la", "ng", "ke", "li", "me", "de", "si", "ne", "ta", "ra", "mo", "du", "pi", "ze"];

export default function program(yaz = console.log) {
  // Belirli (her koşuda aynı) ~1 MB metin: 20.000 satır × 10 kelime.
  // x = (x * 1103515245 + 12345) mod 2^31 — çarpımın düşük bitleri Math.imul ile tam.
  let x = 42;
  const satirlar = [];
  for (let s = 0; s < 20000; s++) {
    const kelimeler = [];
    for (let k = 0; k < 10; k++) {
      x = (Math.imul(x, 1103515245) + 12345) & 0x7fffffff;
      const heceSayisi = (x >>> 16) % 3 + 1;
      let kelime = "";
      for (let h = 0; h < heceSayisi; h++) {
        x = (Math.imul(x, 1103515245) + 12345) & 0x7fffffff;
        kelime += HECELER[(x >>> 16) % 16];
      }
      kelimeler.push(kelime);
    }
    satirlar.push(kelimeler.join(" "));
  }
  const metin = satirlar.join("\n");

  const sayilar = new Map();
  let toplam = 0;
  for (const satir of metin.split("\n")) {
    for (const kelime of satir.split(" ")) {
      sayilar.set(kelime, (sayilar.get(kelime) || 0) + 1);
      toplam++;
    }
  }

  let enSik = "", enCok = 0, harf = 0;
  for (const [kelime, adet] of sayilar) {
    harf += kelime.length * adet;
    if (adet > enCok || (adet === enCok && kelime < enSik)) {
      enSik = kelime;
      enCok = adet;
    }
  }
  yaz([metin.length, toplam, sayilar.size, enSik, enCok, harf].join(" "));
}

// `node program.js` ile de koşar (tarayıcıda ölçüm işçisi program()ı çağırır).
if (globalThis.process?.argv?.[1]?.endsWith("program.js")) program();