Говорили что Перл старый, ни на что не способный язык. Проверим?(часть 2)

#!/usr/bin/perl

open D, 'vxod.txt';
open V, '>vyxod.txt';

while (<D>) {print V if s/([^+\s]*?)([^+\s]*)[\s+]+\2/$1$2/}

#!/usr/bin/env python
import difflib, sys
w1, w2, *_ = sorted(sys.argv[1:], key=lambda s: len(s))
m = difflib.SequenceMatcher(None, w1, w2).find_longest_match()
print(w2 + w1[m.size:])

module Main where
import Control.Monad
import Data.Array.IO
import Data.Foldable
import System.Environment
main =
    do [arg] <- getArgs
       let size = read arg
       primes <- newArray (2, size) True :: IO (IOUArray Int Bool)
       forM_ (takeWhile (\i -> i*i <= size) [2..]) $ \i -> do
         isPrime <- readArray primes i
         if not isPrime
           then return ()
           else forM_ [2*i, 3*i .. size] $ \j -> writeArray primes j False
       let check :: (Int, Int) -> Int -> IO (Int, Int)
           check (j, k) i = do
             isPrime <- readArray primes i
             return $ if isPrime then (i, k+1) else (j, k)
       jk <- foldM check (0, 0) [2..size]
       print jk

это неверно. на js еще попобовал:

#!/usr/bin/env node
let [longest, shortest] = process.argv.slice(2).sort((a, b) => b.length - a.length)
let i = shortest.length
while (--i) {
  if (longest.slice(-i) == shortest.slice(0, i)) break
}
console.log(longest + shortest.slice(i))

~/workspace via ⬢ v16.13.0 via 🐍 v3.10.0 took 7s 
➜ chmod +x sharada.js

~/workspace via ⬢ v16.13.0 via 🐍 v3.10.0 
➜ ./sharada.js шлакоблок окунь
шлакоблокунь

~/workspace via ⬢ v16.13.0 via 🐍 v3.10.0 
➜ ./sharada.js окунь шлакоблок
шлакоблокунь

~/workspace via ⬢ v16.13.0 via 🐍 v3.10.0 
➜ ./sharada.js папа папаха    
папахапапа

#include <iostream>
#include <fstream>
#include <regex>
using namespace std;

int main(){
  string u = "";

  ifstream D ( "vxod.txt");
  ofstream V; V.open("vyxod.txt");

  while (getline(D, u)){
    u = std::regex_replace(u, std::regex(R"(([^+\s]*?)([^+\s]*)[\s+]+\2)"), "$1$2");
    u +="\n"  ;
    cout << u;
    V << u;
  }
  return 0;
}

// Скрипт создан программой perl2cpp-prokhorov: http://chajnik.ru/perl2cpp
//// На основе исходной программы на Perl.

Тред не читал

portmanteau a b = take n a ++ b
  where n = head [ x | x <- [0..length a], drop x a == take (length a - x) b ]
main = getContents >>= mapM_ (putStrLn . (\[a, b] -> portmanteau a b) . words) . lines

def check_combine
    mref res:string
    cref s1:string s2:string
    *len2 @int @size s2
    *j @int 0
    for *ch in s1
        if j len2
            break
        if ch s2|j
            j + 1
        else
            j = 0
    if < j 6 # 3 russian letters
        res = ""
    else
        *s3 @string s2 @erase 0 j
        res = s1 + s3
    
def main
    *inFile @file @set_mode "r" @open "russian_nouns.txt"
    *outFile @file @set_mode "w" @open "out_file.txt"
    *sOut @string ""
    *lines @array|string 
    lines inFile @getlines
    *counter @int 0
    for *s1 in lines
        for *s2 in lines
            if s1 s2
                continue
            *res @string @check_combine s1 s2
            if res s1
                continue
            if res s2
                continue
            if != res ""
                sOut + res " = " s1 " + " s2 "\n"
                counter + 1
                *ret @int counter % 1000
                if ret 0
                    @print "."
                    outFile @write sOut
                    sOut @clear
    outFile @write sOut 
    
    inFile @close
    outFile @close 

     

Я лучше сделаю по другому. Подправлю транслированный текст, чтобы не надо было типы и библиотеки DSL-а использовать, и выложу сюда.

#include <iostream>
#include <fstream>
#include <ctime>
#include <string>
#include <vector>
using namespace std;

void check_combine(string &res, size_t &len, const string &s1, const string &s2)
{
    len = 0;
    for(auto &ch: s1)
    {
        if(len == s2.size())
        {
            break;
        }
        if(ch == s2.at(len))
        {
            len += 1;
        }
        else
        {
            len = 0;
        }
    }
    if(!len)
    {
        res = "";
    }
    else
    {
        string s3  {s2};
        s3.erase(0, len);
        res = s1;
        res += s3;
    }
}

void getlines(vector<string> &lines, fstream & f)
{
    string str;
    while(getline(f, str))
    {
        lines.push_back(str);
    }
}

int main()
{
    fstream inFile;
    inFile.open ("russian_nouns.txt", std::fstream::in);
    vector<string> lines;
    getlines(lines, inFile);
    size_t maxLen  {0};
    size_t rusMaxLen  {0};
    string maxRes  {""};
    time_t startTime = time(nullptr);
    size_t counter  {0};
    for(auto &s1: lines)
    {
        for(auto &s2: lines)
        {
            counter += 1;
            if(s1 == s2)
            {
                continue;
            }
            if(s1.size() < maxLen)
            {
                continue;
            }
            if(s2.size() < maxLen)
            {
                continue;
            }
            size_t len  {0};
            string res;
            check_combine(res, len, s1, s2);
            if(res == s1)
            {
                continue;
            }
            if(res == s2)
            {
                continue;
            }
            if(len > maxLen)
            {
                maxLen = len;
                rusMaxLen = maxLen / 2;
                time_t delta = time(nullptr) - startTime;
                string deltaStr  {s2};
                deltaStr.erase(len);
                maxRes = deltaStr + " - " + s1 + '-' + s2;
                cout << counter << "\t прошло: " << delta << " секунд, длина: ";
                cout << rusMaxLen << ", " << maxRes << '\n';
            }
        }
    }
    cout << "\n\nРезультат: " << rusMaxLen << ", " << maxRes << '\n';
    time_t delta = time(nullptr) - startTime;
    cout << "Полное время переборов: " << delta;
    inFile.close();
    return 0;
}

Вкачусь и я, что ли. Кресты, требуются системные вызовы open, stat и mmap. Подсчитывается длина слова в байтах / 2, а не в символах. Обычно русские буквы занимают 2 байта, отсюда деление на 2. В остальном решение полностью честное.


#include <cassert>
#include <unistd.h>
#include <iostream>
#include <string_view>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <vector>
#include <algorithm>

int main() {
    constexpr auto filename = "russian_nouns.txt";
    int file = open(filename, O_RDONLY);
    if (file < 0) {
        perror("open failed: %s");
        return EXIT_FAILURE;
    }
    struct stat statbuf;
    if (fstat(file, &statbuf)) {
        perror("fstat failed: %s");
        return EXIT_FAILURE;
    }
    auto ptr = mmap(NULL, statbuf.st_size, PROT_READ, MAP_PRIVATE, file, 0);
    if (ptr == MAP_FAILED) {
        perror("mmap failed: %s");
        return EXIT_FAILURE;
    }

    std::vector<const char*> newlines;
    newlines.reserve(1024 * 1024);
    {
        auto begin = reinterpret_cast<char*>(ptr);
        auto end = begin + statbuf.st_size;

        newlines.push_back(begin - 1);
        while (begin != end) {
            if (*begin == '\n') {
                newlines.push_back(begin);
            }
            ++begin;
            //begin = std::find(begin, end, '\n');
        }
        if (newlines.size() > 0 && *newlines.back() != '\n') {
            ++newlines.back();
        }
    }

    std::size_t max_common_len{ 0 };
    for (std::size_t i = 0; i + 1 < newlines.size(); ++i) {
        std::string _( newlines[i] + 1, newlines[i + 1] - newlines[i] - 1 );
        if (_.size() < max_common_len) {
            continue;
        }
        std::string_view a{ _ };
        for (std::size_t j = 0; j + 1 < newlines.size(); ++j) {
            std::string_view b( newlines[j] + 1, newlines[j + 1] - newlines[j] - 1 );
            if (newlines[i] == newlines[j] || b.size() < max_common_len) {
                continue;
            }
            auto max = std::min(a.size(), b.size());
            if (max <= max_common_len || a.ends_with(b) || b.starts_with(a)) {
                continue;
            }
            auto a_ = a;
            auto b_ = b;
            a_.remove_prefix(a.size() - max);
            b_.remove_suffix(b.size() - max);
            while (max > max_common_len) {
                if (a_.ends_with(b_)) {
                    max_common_len = max;
                    std::cout << (max / 2) << ' ' << a << " + " << b << " = " << a << b.substr(b_.size()) << '\n';
                    break;
                }
                b_.remove_suffix(1);
                --max;
            }
        }
    }
}

Я дописал подпрограмму для расчёта без регулярок - Время одинаковое что и с правильной регуляркой.

#!/usr/bin/perl

use utf8;
use open qw(:std :utf8); 

$t = time();

$| = 1;
open D, 'russian_nouns.txt';

for(0..3000) {
  $vv=<D>;
  $vv =~ s/\s+$//;
  @d = (@d, $vv);
  }

close D;
@d2 = @d;


for $v (@d){
    ++$ii; if (++$j>99){
    $t2 = time()-$t;
    print $ii." прошло $t2 секунд. $sov1 $str\n"; $j=0;}

  for $v2 (@d2) {&resh3 ()}
  
M1:  
  }
  
sub resh3 {
  
  $lv = length $v;
  $lv2 = length $v2;

  if($lv>$lv2) {
  
    for($i=$lv2; $i>1; $i--) {
      $c = substr ($v, -$i,);
      $c2 = substr ($v2, 0, $i);
      if (($c eq $c2) and ($c ne $v2) and ($c ne $v)){
          $sov = length $c;
          if ($sov>$sov1){$sov1=$sov; $str="$c = $v-$v2"}
          }
        
  
      }

  
  }
  else {
    
        for($i=$lv; $i>1; $i--) {
      $c = substr ($v2, -$i,);
      $c2 = substr ($v, 0, $i);
      if (($c eq $c2) and ($c ne $v2) and ($c ne $v)){
          $sov = length $c;
          if ($sov>$sov1){$sov1=$sov; $str="$c = $v-$v2"}
          }
        
  
      }
    
    
    
    }
  
  
}
  

sub resh1 {  
    $r=''; $l='';
    for(split(//,$v2)){
      $r .= $_;
      if ($v =~ /$r$/) {$l=$r}  
      }
    #print "$v-$l-$v2\n" if length $l>4 and $v ne $l;
    
    if ($l and ($l ne $v2) and ($l ne $v)){
    $sov = length $l;
    if ($sov>$sov1){$sov1=$sov; $str="$l - $v-$v2"}
}
}


sub resh2 {
  
    if($v ne $v2) {
    $_ = "$v $v2";
    /([^ ]*?)([^ ]*) \2/;
    
    if ($2 and ($2 ne $v2) and ($2 ne $v)){
    $sov = length $2;
    if ($sov>$sov1){$sov1=$sov; $str="$2 - $_"}

}
  }}
  

Поздравляю! Вернусь к теме о суммарном времени написания и выполнения кода. Изначальный код на моём самодельном языке был такой:

import time

def check_combine
    mref res:string len:int
    cref s1:string s2:string
    *len2 @int @size s2
    len = 0
    for *ch in s1
        if len len2
            break
        if ch s2|len
            len + 1
        else
            len = 0
    ifnot len
        res = ""
    else
        *s3 @string s2 @erase 0 len
        res = s1 + s3
    
def main
    *inFile @file @set_mode "r" @open "russian_nouns.txt"
    *lines @array|string 
    lines inFile @getlines
    *maxLen @int 0
    *rusMaxLen @int 0
    *maxRes @string ""
    *startTime @int @time:time
    *counter @int 0
    for *s1 in lines
        for *s2 in lines
            counter + 1
            if s1 s2
                continue
            *len1 @int @size s1
            *len2 @int @size s2
            if < len1 maxLen
                continue
            if < len2 maxLen
                continue
            *len @int 0
            *res @string
            res len @check_combine s1 s2
            if res s1
                continue
            if res s2
                continue
            if > len maxLen
                maxLen = len
                rusMaxLen = maxLen / 2
                *delta @int @time:time - startTime
                *deltaStr @string s2 @erase len
                maxRes = deltaStr + " - " s1 "-" s2
                @print* counter "\t прошло: " delta " секунд, длина: " rusMaxLen ", " maxRes "\n"
    @print* "\n\nРезультат: " rusMaxLen ", " maxRes "\n" 
    *delta @int @time:time - startTime
    @print* "Полное время переборов: " delta
    inFile @close

По длине он 1673 символа против 2457 на C++. То есть примерно в 1,5 раза короче. При том, можно ещё сократить, если сделать простейший вывод типов в конструкторе, а также открыть доступ к длине строки через переменную (это будет плохо с точки зрения инкапсуляции, но для маленьких одноразовых программ такое оправдано).

Но это не потому что C++ плохой. Для больших многоразовых программ он лучше. Если команда работает - он лучше, хотя хуже, чем Java и C#. Для маленьких одноразовых программ лучше были Перл и Питон, если нет требований по времени. Но Перл теперь заменяют на Раку, а Питон переусложнили.

Входной файл

https://dropmefiles.com/z7VlC

С++

#include <iostream>
#include <fstream>
#include <time.h>
#include <pcre.h>
#include <string.h>
using namespace std;

#define kOUTPUT_ENABLED 0

int main(int argc, char *argv[]) {
  ifstream file("vxod.txt");
  ofstream outputFile("vyxod.txt");
  string linee;
  clock_t start = clock();
  const char* prce_error;
  int pcre_erroff;
  int match[9] = {0};
  char buffer[256] = {0};
  auto regex = pcre_compile("([^+ ]*?)([^+ ]*)[ +]+\\2", PCRE_UTF8, &prce_error, &pcre_erroff, 0);
  while (getline(file, linee)) {
    auto line = linee.c_str();
    auto rc = pcre_exec(regex, 0, line, strlen(line), 0, PCRE_ANCHORED, match, 9);
    int s2 = match[2*1];
    int s1 = match[2*1+1] - match[2*1];
    int s4 = match[2*2];
    int s3 = match[2*2+1] - match[2*2];
    int start = s4 + s3 + 3;
    int length = strlen(line) - start;
    sprintf(buffer, "%.*s%.*s\n",s1, line + s2,length, line + start);
    #if kOUTPUT_ENABLED
    cout << buffer;
    #endif
    outputFile << buffer;
  }
  double time = (double)(clock() - start) / CLOCKS_PER_SEC;
  cout << "Perform time: " << time << " seconds "<< endl;
};

Запускаем

clang++ wordcrossPCRE.cpp -lpcre -O3 && ./a.out
Perform time: 2.58932 seconds 

Perl слил Сишному PCRE

УНЫЛАЯ ДО БЕЗОБРАЗИЯ ...

Вас интересуют алгоритмы типа "ширпотреб" или "люкс"?  
``

#!/usr/bin/perl

use utf8;
use open qw(:std :utf8); 

$t = time();

$| = 1;
open D, 'russian_nouns.txt';

for(0..3000) {
  $vv=<D>;
  $vv =~ s/\s+$//;
  @d = (@d, $vv);
  }

close D;
@d2 = @d;


for $v (@d){
    ++$ii; if (++$j>99){
    $t2 = time()-$t;
    print $ii." прошло $t2 секунд. $sov1 $str\n"; $j=0;}

  for $v2 (@d2) {&resh3 ()}
  
M1:  
  }

&resh5 {
# Слова находятся в $v и в $v2


}

Но не хуже чем в других языках программирования