String Zip e Sort

14

Dato un elenco di stringhe, genera una singola stringa formata prendendo un carattere da ciascuna stringa in ciascuna posizione, ordinandole per ordinale ASCII e aggiungendole in ordine alla stringa di output. In altre parole, per le nstringhe di input, i primi ncaratteri dell'output saranno i primi caratteri di ciascuno degli input ordinati per ordinale, i secondi ncaratteri dell'output saranno i secondi caratteri di ciascuno degli input ordinati per ordinale, e così su. Puoi presumere che le stringhe abbiano tutte la stessa lunghezza e che ci sarà almeno una stringa. Tutte le stringhe saranno composte solo da caratteri ASCII stampabili (ordinali 32-127).

Implementazione di riferimento in Python ( provalo online ):

def stringshuffle(strings):
  res = ''
  for i in range(len(strings[0])):
    res += ''.join(sorted([s[i] for s in strings],key=ord))
  return res

Esempi:

"abc","cba" -> "acbbac"
"HELLO","world","!!!!!" -> "!Hw!Eo!Lr!Ll!Od"

Regole

  • Sono vietate le scappatoie standard
  • Questo è code-golf , quindi vince la risposta più breve in byte

Classifica

Lo snippet di stack nella parte inferiore di questo post genera la classifica dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad esempio perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

code-golf  string 
— Mego
fonte

Risposte:

11

GS2 , 4 byte

*Ü■/

Questo legge le stringhe da STDIN, separate da avanzamenti di riga.

Il codice sorgente utilizza la codifica CP437 . Provalo online!

Prova

$ xxd -r -ps <<< '2a 9a fe 2f' > zip-sort.gs2
$ echo -e 'HELLO\nworld\n!!!!!' | gs2 zip-sort.gs2 
!Hw!Eo!Lr!Ll!Od

Come funziona

*       Split the input into the array of its lines.
 Ü      Zip the resulting array.
  ■     Map the rest of the program over the resulting array.
   /        Sort.
— Dennis
fonte
6

Haskell, 39 36 byte

import Data.List
(>>=sort).transpose

Esempio di utilizzo: ((>>=sort).transpose) ["HELLO","world","!!!!!"]-> "!Hw!Eo!Lr!Ll!Od".

Traspone l'elenco di stringhe, mappalo sortsu di esso e concatena l'elenco di stringhe risultante ( >>=nel contesto dell'elenco è concatMap).

— Nome del modello
fonte
mi è venuto in mente esattamente questo!
— orgoglioso haskeller il
Io no; Continuo a dimenticare di sfruttare l'istanza Monad per cose come le liste. (+1)
— ballesta25,
5

TeaScript , 9 byte

_t¡ßlp¡)µ

TeaScript ha tutti i giusti incorporati implementati in tutti i modi sbagliati.

Provalo online

Ungolfed

_t()m(#lp())j``

Spiegazione

_t()        // Transposes input array
    m(#     // Loops through inputs
       lp() // Sorts characters by char code
     )
j``         // Joins back into string
— Downgoat
fonte
@intrepidcoder funziona bene per me. Forse il tuo browser ha memorizzato nella cache alcuni file? Forse svuotare la cache potrebbe funzionare. Sto usando Safari però. Proverò ad aggiornare i file
— Downgoat,
4

Python, 50 48 byte

lambda x,y=''.join:y(map(y,map(sorted,zip(*x))))

Grazie a @xnor per -2 byte!

— Dennis
fonte
4
È possibile salvare "".joinin una variabile.
— xnor
Oh, non ne avevo idea. Grazie!
— Dennis,
4

JavaScript (ES6), 57 byte

a=>a[0].replace(/./g,(c,i)=>a.map(w=>w[i]).sort().join``)
— George Reith
fonte
3

Ottava, 15 byte

@(a)sort(a)(:)'

Esempio:

octave:1> (@(a)sort(a)(:)')(["abc";"cba"])
ans = acbbac
octave:2> (@(a)sort(a)(:)')(["HELLO";"world";"!!!!!"])
ans = !Hw!Eo!Lr!Ll!Od
— alephalpha
fonte
2

Julia, 46 byte

x->(j=join)(map(i->j(sort([i...])),zip(x...)))

Ciò crea una funzione senza nome che accetta una matrice di stringhe e restituisce una stringa. Per chiamarlo, dagli un nome, ad es f=x->....

Ungolfed:

function zipsort{T<:AbstractString}(x::Array{T,1})
    # Splat the input array and zip into an iterable
    z = zip(x...)

    # For each tuple consisting of corresponding characters
    # in the input array's elements, splat into an array,
    # sort the array, and join it into a string
    m = map(i -> join(sort([i...])), z)

    # Take the resulting string array and join it
    return join(m)
end
— Alex A.
fonte
1

Minkolang 0,13 , 46 byte

$od0Z2:$zIz:$xd0G2-[i1+z[di0c*+c$r]xz$(sr$Ok].

Provalo qui. Si aspetta input come "HELLO""world""!!!!!"(quindi nessuna virgola).

Spiegazione

$o     Read in whole input as characters
d      Duplicate top of stack (the ")
0Z     Count how often this appears in the stack
2:     Divide by two
$z     Store this in the register (z)
Iz:    Length of stack divided by z (k)
$x     Dump one element from the front/bottom of stack
d      Duplicate top of stack (which is k)
0G     Insert it at the front/bottom of stack
2-     k-2

  [                              Open for loop that repeats k-2 times
   i1+                           Loop counter + 1 (i)
      z[                         Open for loop that repeats z times
        d                        Duplicate top of stack (which is i)
         i                       Loop counter (j)
          0c                     Copy k from front of stack
            *                    Multiply (j*k)
             +                   Add (j*k + i)
              c                  Copy character at position j*k+i to the top
               $r                Swap top two elements of stack (so i is on top)
                 ]               Close for loop
                  x              Dump the top of stack (dump i)
                   z$(           Start a new loop with the top z elements
                      s          Sort
                       r$O       Reverse and output the whole (loop) stack as characters
                          k      Break - exits while loop
                           ].    Close for loop and stop
— El'endia Starman
fonte
1

GolfScript, 8 byte

~zip{$}%

Provalo online su Web GolfScript .

Come funziona

~         # Evaluate the input.
 zip      # Zip it.
    {$}%  # Map sort ($) over the resulting array.
— Dennis
fonte
1

K, 10 byte

,/{x@<x}'+

Join ( ,/) il tipo di ( {x@<x}) each ( ') del transpose ( +) di un elenco di stringhe.

In azione:

  ,/{x@<x}'+("HELLO";"world";"!!!!!")
"!Hw!Eo!Lr!Ll!Od"

Semplice, ma K è ferito un po 'qui non avendo una funzione di ordinamento a carattere singolo e invece dividendo l'operazione in un operatore di indice di dispersione-raccolta @e una primitiva che produce il vettore di permutazione che ordinerebbe un elenco <.

— JohnE
fonte
1

C ++ 14, 152 byte

#include<iostream>
#include<regex>
[](auto s){for(int i=0;i<s[0].size();++i){auto r=""s;for(auto k:s)r+=k[i];std::sort(begin(r),end(r));std::cout<<r;}};

Non usare alcun vantaggio di map + zip (indovina perché)

Ungolfed + utilizzo

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

int main()
{
    auto lambda = [](auto s)
    {
        for (int i = 0; i < s[0].size(); ++i)
        {
            auto r = ""s;
            for (auto k : s)
                r += k[i];
            std::sort(begin(r), end(r));
            std::cout << r;
        }
    };

    std::vector<std::string> data = { "HELLO", "world", "!!!!!" };
    lambda(data);
}
— Zereges
fonte
1

Mathematica, 51 byte

""<>SortBy@ToCharacterCode/@Transpose@Characters@#&

La manipolazione delle stringhe in Mathematica è costosa ...

— LegionMammal978
fonte
1

Japt , 12 byte 20

Ny m_q n q)q

Provalo online!

Spiegazione

Ny       // Transpose inputs
  m_     // Maps through each new string
    q    // Split string
    n    // Sort string
    q    // Join
)q       // Join again
— Downgoat
fonte
1

PHP ,92 91 byte

for($argv[0]='';$a=array_column(array_map(str_split,$argv),$i++|0);print join($a))sort($a);

Provalo online!

Sono sicuro che questo potrebbe essere fatto più breve non provando a usare le funzioni di array integrate di PHP, ma ho dovuto provare!

O 85 byte

L'oscillazione di @ Night2, resa più breve non tentando di utilizzare le funzioni di array integrate di PHP:

for(;''<$argv[1][$i++];print join($a))for($a=[];''<$a[]=$argv[++$$i][$i-1];sort($a));

Provalo online!

— 640KB
fonte
@ Night2 ben fatto! Dovresti pubblicarlo come tuo. È un peccato che array_columnnon funzionerà su una serie di stringhe, altrimenti sarebbe molto più utile per CG. E ovviamente dover saltare $argv[0]è sempre anche un dolore ...
— 640 KB
0

Clojure / ClojureScript, 43 byte

#(apply str(mapcat sort(apply map list %)))

Crea una funzione anonima. Scritto in un REPL ClojueScript, dovrebbe essere valido anche Clojure.

Inseriscilo qui , quindi chiama via (*1 ["HELLO" "world" "!!!!!"]). Oppure fai (def f *1)e poi usa (f ["abc" "cba"]).

— MattPutnam
fonte
0

Ceylon, 166

String z(String+l)=>String(expand(t(l).map(sort)));[T+]n<T>(T?+i)=>[for(e in i)e else nothing];{[X+]*}t<X>([{X*}+]l)=>l[0].empty then{}else{n(*l*.first),*t(l*.rest)};

Mentre Ceylon ha una zipfunzione , ci vogliono solo due iterabili anziché uno iterabile. unzip, d'altra parte, prende una moltitudine di tuple e non voglio convertire le mie corde in tuple. Quindi ho implementato la mia funzione di trasposizione, ispirata da un'implementazione di Haskell che Google ha trovato per me da qualche parte .

// zip-sort
//
// Question:  http://codegolf.stackexchange.com/q/64526/2338
// My answer: ...

// Takes a list of strings (same length), and produces
// a string made by concatenating the results of sorting
// the characters at each position.
String z(String+ l) =>
        String(expand(t(l).map(sort)));

// Narrow an iterable of potential optionals to their non-optional values,
// throwing an AssertionError if a null is in there.
[T+] n<T>(T?+ i) =>
        [for (e in i) e else nothing];

// Transpose a nonempty sequence of iterables, producing an iterable of
// sequences.
// If the iterables don't have the same size, either too long ones are
// cut off or too short ones cause an AssertionError while iterating.
{[X+]*} t<X>([{X*}+] l) =>
        l[0].empty
        then {}
        else { n(*l*.first), *t(l*.rest) };

I tipi di ne tpotrebbero essere definiti molto più generali, ma questo è Codegolf ;-) ( nè un caso speciale di ciò che ho proposto assertNarrowdue settimane fa ).

— Paŭlo Ebermann
fonte
0

Perl 6 , 33 byte

{[~] flat ([Z] @_».comb)».sort}

Esempio di utilizzo:

say {[~] flat ([Z] @_».comb)».sort}(< abc cba >) # acbbca

my &code = my $code = {[~] flat ([Z] @_».comb)».sort}

say code "HELLO","world","!!!!!"; # !Hw!Eo!Lr!Ll!Od

say ((<cba abc>),(<testing gnitset gttseni>)).map($code);
# (acbbac ggtentiststteisenngit)
— Brad Gilbert b2gills
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.