Zip et tri des chaînes

14

Étant donné une liste de chaînes, sortez une chaîne unique formée en prenant un caractère de chaque chaîne à chaque position, en les triant par ordinal ASCII et en les ajoutant dans l'ordre à la chaîne de sortie. En d'autres termes, pour nles chaînes d'entrée, les premiers ncaractères de la sortie seront les premiers caractères de chacune des entrées triées par ordinal, les seconds ncaractères de la sortie seront les seconds caractères de chacune des entrées triées par ordinal, etc. sur. Vous pouvez supposer que les chaînes sont toutes de longueur égale et qu'il y aura au moins une chaîne. Toutes les chaînes seront composées uniquement de caractères imprimables ASCII (ordinaux 32-127).

Implémentation de référence en Python ( essayez-la en ligne ):

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

Exemples:

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

Règles

  • Les failles standard sont interdites
  • Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte

Classement

L'extrait de pile au bas de cet article génère le classement à partir des réponses a) en tant que liste des solutions les plus courtes par langue et b) en tant que classement général.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Afficher l'extrait de code

code-golf  string 
— Mego
source

Réponses:

11

GS2 , 4 octets

*Ü■/

Cela lit les chaînes de STDIN, séparées par des sauts de ligne.

Le code source utilise l' encodage CP437 . Essayez-le en ligne!

Essai

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

Comment ça fonctionne

*       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
source
6

Haskell, 39 36 octets

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

Exemple d'utilisation: ((>>=sort).transpose) ["HELLO","world","!!!!!"]-> "!Hw!Eo!Lr!Ll!Od".

Transposer la liste de chaînes, mapper sortdessus et concaténer la liste résultante de chaînes ( >>=dans le contexte de la liste est concatMap).

— nimi
source
j'ai trouvé exactement ça!
— fier haskeller
Je n'ai pas; J'oublie toujours d'exploiter l'instance Monad pour des choses comme les listes. (+1)
— ballesta25
5

TeaScript , 9 octets

_t¡ßlp¡)µ

TeaScript a tous les bons intégrés implémentés de toutes les mauvaises manières.

Essayez-le en ligne

Non golfé

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

Explication

_t()        // Transposes input array
    m(#     // Loops through inputs
       lp() // Sorts characters by char code
     )
j``         // Joins back into string
— Downgoat
source
@intrepidcoder fonctionne très bien pour moi. Peut-être que votre navigateur a mis en cache certains fichiers? Peut-être que vider votre cache pourrait fonctionner. J'utilise cependant Safari. Je vais essayer de rafraîchir les fichiers
— Downgoat
4

Python, 50 48 octets

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

Merci à @xnor pour -2 octets!

— Dennis
source
4
Vous pouvez enregistrer "".joindans une variable.
— xnor
Oh, je n'en avais aucune idée. Merci!
— Dennis
4

JavaScript (ES6), 57 octets

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

Octave, 15 octets

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

Exemple:

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

Julia, 46 octets

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

Cela crée une fonction sans nom qui accepte un tableau de chaînes et renvoie une chaîne. Pour l'appeler, donnez-lui un nom, par exemple f=x->....

Non golfé:

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.
source
1

Minkolang 0,13 , 46 octets

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

Essayez-le ici. Attend une entrée comme "HELLO""world""!!!!!"(donc pas de virgules).

Explication

$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
source
1

GolfScript, 8 octets

~zip{$}%

Essayez-le en ligne sur Web GolfScript .

Comment ça fonctionne

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

K, 10 octets

,/{x@<x}'+

Joignez ( ,/) le type de ( {x@<x}) chacun ( ') de la transposition ( +) d'une liste de chaînes.

En action:

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

Simple, mais K est un peu blessé ici en n'ayant pas de fonction de tri à un seul caractère et en divisant plutôt l'opération en un opérateur d'index de dispersion-collecte @et une primitive qui donne le vecteur de permutation qui trierait une liste <.

— JohnE
source
1

C ++ 14, 152 octets

#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;}};

Ne pas utiliser d'avantage de carte + zip (devinez pourquoi)

Ungolfed + usage

#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
source
1

Mathematica, 51 octets

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

La manipulation des chaînes dans Mathematica coûte cher ...

— LegionMammal978
source
1

Japt , 12 octets 20

Ny m_q n q)q

Essayez-le en ligne!

Explication

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

PHP ,92 91 octets

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

Essayez-le en ligne!

Je suis convaincu que cela pourrait être fait plus rapidement en n'essayant pas d'utiliser les fonctions de tableau intégrées de PHP, mais j'ai dû essayer!

Ou 85 octets

Le swing de Night2, raccourci en n'essayant pas d'utiliser les fonctions de tableau intégrées de PHP:

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

Essayez-le en ligne!

— 640 Ko
source
@ Night2 bien fait! Vous devez publier celui-ci comme le vôtre. C'est dommage que array_columncela ne fonctionne pas sur un tableau de chaînes, sinon ce serait un peu plus utile pour CG. Et bien sûr, devoir sauter $argv[0]est toujours aussi une douleur ...
— 640KB
0

Clojure / ClojureScript, 43 octets

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

Crée une fonction anonyme. Écrit dans un ClojueScript REPL, devrait également être un Clojure valide.

Entrez-le ici , puis appelez via (*1 ["HELLO" "world" "!!!!!"]). Ou faites (def f *1), puis utilisez (f ["abc" "cba"]).

— MattPutnam
source
0

Ceylan, 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)};

Alors que Ceylan a une zipfonction , il ne prend que deux itérables au lieu d'un itérable d'entre eux. unzip, en revanche, prend un itérable de tuples, et je ne veux pas convertir mes chaînes en tuples. J'ai donc implémenté ma propre fonction de transposition, inspirée d'une implémentation Haskell que Google m'a trouvée quelque part .

// 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) };

Les types de net tpourraient être définis beaucoup plus généraux, mais c'est Codegolf ;-) ( nest un cas particulier de ce que j'ai proposé il y a assertNarrowdeux semaines ).

— Paŭlo Ebermann
source
0

Perl 6 , 33 octets

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

Exemple d'utilisation:

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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.