Poliglotul Maxxie și Minnie | R-bloggeri

R

Sunt cel mai familiarizat cu R, așa că îmi place să încep de acolo. Am creat un swap
funcție care schimbă un vector la niște indici, împreună cu niște ajutoare, astfel încât să pot folosi pmap_int() cu adevărat curat.

swap <- function(x, y, v) {
   xx <- v(x)
   yy <- v(y)
   v(x) <- yy
   v(y) <- xx
   v
}

chr_swap <- function(x, y, v) {
   paste0(swap(x, y, v), collapse = "")
}

toInt_swap <- function(x, y, v) {
   as.integer(chr_swap(x, y, v))
}

maxmin <- function(num) {
  chars <- strsplit(as.character(num), "")((1))
  n <- nchar(num)
  s <- seq_len(n)
  opts <- expand.grid(x = s, y = s)
  opts$v <- list(chars)
  vals <- purrr::pmap_int(opts, toInt_swap)
  keeps <- vals(nchar(vals) == n)
  c(max(keeps), min(keeps))
}

maxmin(213)
(1) 312 123  
maxmin(12345)  
(1) 52341 12345  
maxmin(100)
(1) 100 100  
maxmin(11321)
(1) 31121 11123 

The expand.grid() creează unele combinații redundante, dar acestea cad în mod natural, așa că nu m-am obosit să le filtrez. De asemenea, deoarece aceasta include schimburile fără operațiuni (de exemplu, indicele de schimb 2 şi 2) conține deja vectorul original. Mai degrabă decât filtrarea la vectorii numerelor întregi nu
începând cu 0, am filtrat la cele care conțin numărul corect de cifre după convertirea înapoi în întreg, care este echivalent.

Încercați să lipiți codul în editorul online {webr} aici; Nu sunt sigur dacă este posibil să se conecteze la o stare existentă, dar când vă întreabă dacă doriți să instalați {purrr} în interfață, răspundeți că o faceți.

APL

În Dyalog APL este mai ușor să definiți o funcție de swap; cel @ operatorul ia o funcție (invers) deci s aici efectuează un schimb. Produsul exterior este super la îndemână pentru a găsi toate combinațiile de x şi y: x ∘., y.

maxmin←{
  ⎕IO←1  ⍝ so that x(1) is subset not x(0)
  n←⍎¨⍕⍵  ⍝ convert int to vec 
  s←{⌽@⍵⊢⍺}  ⍝ swap two elements
  swaps←{n s ⍵}  ⍝ apply swaps to a vec n
  opts←,(⍳≢n)∘.,⍳≢n ⍝ combinations of 1..n
  new←swaps¨opts  ⍝ perform the swaps
  keep←(~0=⊃¨new)/new  ⍝ filter out values starting with 0
  (⌈/,⌊/)10⊥¨keep  ⍝ max and min of ints
}

     maxmin 213 
312 123
     maxmin 12345 
52341 12345
     maxmin 100 
100 100
     maxmin 11321
31121 11123

Sunt destul de multumit de aceasta solutie; efectuând a map este la fel de simplu ca să folosești fiecare (¨) și efectuând ambele max şi min concatenate împreună cu o furculiță ((⌈/,⌊/)) este atât de estetic. Conversia dintr-un vector de numere într-un singur număr utilizează o decodare în bază 10 (10⊥) care este modul în care ar putea fi necesar să faceți asta în alte limbi, dar cu o buclă.

Dacă ar fi să îmi iau niște libertăți cu ceea ce se numește „linie”, aș putea spune că aceasta este o soluție cu o linie.

maxmin←{⎕IO←1 ⋄ n←⍎¨⍕⍵ ⋄ s←{⌽@⍵⊢⍺} ⋄ swaps←{n s ⍵} ⋄ opts←,(⍳≢n)∘.,⍳≢n ⋄ new←swaps¨opts ⋄ keep←(~0=⊃¨new)/new ⋄ (⌈/,⌊/)10⊥¨keep }

Puteți încerca acest lucru singur la tryapl.org

Julia

În Julia swap funcția poate folosi destructurarea, ceea ce este drăguț, dar, deoarece limbajul folosește semantică de trecere prin referință, trebuie să fac o copie a vectorului care este schimbat, altfel voi continua să-l schimb mereu și iar. Notă: această postare recentă a mea.

using Combinatorics

function swap(x, i, j)
  y = copy(x)
  y(i), y(j) = y(j), y(i)
  y
end

function maxmin(x)
    nvec = parse.(Int64, split(string(x), ""))
    opts = collect(combinations(1:length(nvec), 2))
    new = ((nvec); map(x -> swap(nvec, x...), opts))
    keep = filter(x -> x(1) != 0, new)
    vals = parse.(Int64, join.(keep))
    (maximum(vals), minimum(vals))
end

maxmin(213)
(312, 123)
maxmin(12345)
(52341, 12345)  
maxmin(100)
(100, 100)  
maxmin(11321)
(31121, 11123)    

Partea cu care am avut probabil cele mai multe probleme aici a fost concatenarea vectorului original cu versiunile lui schimbate; acum pare curat, dar mi-a luat ceva timp să-mi dau seama cum să le aduc pe toate în același vector-de-vectori.

Stropirea de opts variante în map a fost drăguț; nu este nevoie să definiți schimbul în termeni de tuplu. În general, aceasta este o soluție foarte curată, după părerea mea – Julia face într-adevăr un limbaj minunat.

Haskell

Continuând călătoria mea de învățare Haskell, m-am gândit că cel mai bine ar fi să încerc asta. Fiind un limbaj puternic funcțional, nu se definește o mulțime de variabile, în schimb se scrie o mulțime de funcții care vor transmite date. Acest lucru îl face puțin dificil pentru testare, dar am ajuns acolo în cele din urmă. A trebuit să împrumut swapElts funcția și nub a fost una nouă pentru mine (în esență unique()).

import Data.List
import Data.Digits

uniq_pairs l = nub ((x,y) | x <- l, y <- l, x < y)
opts n = uniq_pairs (0..n-1)
-- https://gist.github.com/ijt/2010183
swapElts i j ls = (get k x | (k, x) <- zip (0..length ls - 1) ls)
    where get k x | k == i = ls !! j
                  | k == j = ls !! i
                  | otherwise = x
doswap t v = swapElts (fst t) (snd t) v
newlist v = v : map (x ->  doswap x v) (opts (length v))
keep v = filter (x -> (head x /= 0)) (newlist v)
maxmin n = (maximum(x), minimum(x)) where 
  x = map (unDigits 10) (keep (digits 10 n))

maxmin 213
(312,123)
maxmin 12345
(52341,12345)
maxmin 100
(100,100)
maxmin 11321
(31121,11123)

The Data.Digits pachetul a fost foarte util aici – având digits şi
unDigitsdeși dacă aveam de gând să le folosesc mai mult, aș fi transformat baza 10 necesară în ceva de genul digits10 şi unDigits10.

Sunt posibile îmbunătățiri care trebuie făcute aici și sunt interesat de orice puteți observa!

Piton

„Toată lumea” îl folosește, așa că trebuie să învăț… este ceea ce îmi tot spun. Nu sunt străin de ciudateniile diferitelor limbi, dar de fiecare dată când încerc să fac ceva funcțional în python ajung să fiu supărat că metoda de imprimare pentru generatoare arată adresa de memorie în loc, să zicem, de primele câteva elemente. Imprimarea unei valori și vedea

mă primește fiecare. singur. timp. Da, da, list(value) îl „colectează”, dar grrr…

Python are sintaxa de destructurare care este drăguță în swap funcția, dar din nou este trece prin referință, așa că trebuie să fac mai întâi o copie.

import itertools

def swap(x, t):
    y = x.copy()
    i, j = t
    y(i), y(j) = y(j), y(i)
    return y

def minmax(num): 
    nums = (int(i) for i in str(num))
    opts = itertools.combinations(range(len(nums)), 2)
    new = map(lambda x: swap(nums, x), list(opts))
    keeps = list(filter(lambda x: x(0) != 0, new))
    keeps.append(nums)
    vals = list(map(lambda x: int(''.join(map(str, x))), keeps))
    return (max(vals), min(vals))

minmax(213)
(312, 123)
minmax(12345)
(52341, 12345)
minmax(100)
(100, 100)
minmax(11321)
(31121, 11123)

În afară de mormăielile mele în timp ce scriu, soluția este încă destul de curată. Apelurile către list() intercalate de-a lungul ar putea fi evitată, dar nevoia de a face asta în timp ce mă dezvoltam măcar m-a încetinit.

Rugini

Aproape că nu am făcut o soluție Rust pentru că am crezut că am făcut destul. A ajuns să fie cel mai complicat, totuși – nu sunt sigur dacă asta este din cauza mea sau a lui Rust.

use itertools::Itertools;

fn swap(v: Vec, t1: usize, t2: usize) -> Vec {
    let mut vv = v;
    let tmp1 = vv(t1);
    let tmp2 = vv(t2);
    vv(t1) = tmp2;
    vv(t2) = tmp1;
    return vv;
}

fn maxmin(num: u32) -> (u32, u32) {
    let numc = num.to_string();
    let n = numc.len();
    let numv: Vec = numc
        .to_string()
        .chars()
        .map(|c| c.to_digit(10).unwrap())
        .collect();
    let mut opts = Vec::new();
    for (a, b) in (0..n).tuple_combinations() {
        opts.push((a, b));
    }
    let mut new: Vec> = Vec::new();
    new.push(numv.clone());
    for o in opts {
        new.push(swap(numv.clone(), o.0, o.1));
    }
    let keeps: Vec> = new.into_iter().filter(|x| x(0) != 0).collect();
    let mut vals = Vec::new();
    for v in keeps {
        let tmp: u32 = v
            .clone()
            .into_iter()
            .map(|x| x.to_string())
            .collect::()
            .parse()
            .unwrap();
        vals.push(tmp);
    }
    let min = *vals.iter().min().unwrap();
    let max = *vals.iter().max().unwrap();
    (max, min)
}

fn main() {
    println!("{:?}", maxmin(213));
    println!("{:?}", maxmin(12345));
    println!("{:?}", maxmin(100));
    println!("{:?}", maxmin(11321))
}
(312, 123)
(52341, 12345)
(100, 100)
(31121, 11123)

Această soluție mi-a reamintit de ce îmi place să lucrez cu limbaje matrice (sau cel puțin care suportă vectori); nu este nevoie să bucleți în mod explicit peste fiecare element al unui vector pentru a face ceva. A trebuit să scriu multe push()
bucle pentru a muta datele. max() nu funcționează pe un vector (în sensul găsirii maximului de n elemente); funcționează așa pe un iterator și poate eșua, deci cu atât mai mult min şi max linii.

A trebuit clone() diverse valori în mod explicit pentru că nu pot fi reutilizate a fost puțin enervant, dar înțeleg de ce se plânge de acestea.

Acest lucru a durat mai mult decât mi-aș fi dorit, dar bineînțeles că am învățat mai multe făcând-o.

J

La întâlnirea APL am discutat despre o soluție J parțială care a folosit o abordare ușor diferită a algoritmului de „swap”. Nu sunt sigur că acolo este un mod în J care este la fel de elegant ca soluția APL, dar m-ar interesa dacă există.

Justus Perlwitz a oferit această soluție, a cărei esență este

digits =: 10.^:_1

sd =: {{
  amend =. (|.y)}
  swap =. (y { )) amend )
  swap &.: digits x
}}

cart =: {{
  all =. ,/ (,"0)/~ y
  uniq =. ~. /:~"1 all
  l =. 0{"1 uniq
  r =. 1{"1 uniq
  (l ~: r) # uniq
}}

swapmaxmin =: {{
  ndigits =. (: # digits
  combs =. cart i. ndigits y
  constr =. ((ndigits y) <: (: ndigits"0 )) # )
  swaps =. constr y, y sd"1 combs
  (>./ , <./) swaps
}}

swapmaxmin 213
312 123
swapmaxmin 12345
52341 12345
swapmaxmin 100
100 100
swapmaxmin 11321
31121 11123

și pe care o poți alerga în locul de joacă J

Vreau să învăț multe despre J, așa că voi cerceta și eu această soluție.