स्ट्रिंग ज़िप और सॉर्ट करें

14

तार की एक सूची को देखते हुए, प्रत्येक स्थिति में प्रत्येक स्ट्रिंग से एक चरित्र लेने के द्वारा गठित एकल स्ट्रिंग का उत्पादन किया जाता है, उन्हें ASCII अध्यादेश द्वारा क्रमबद्ध किया जाता है, और आउटपुट स्ट्रिंग के क्रम में उन्हें जोड़ दिया जाता है। दूसरे शब्दों में, nइनपुट स्ट्रिंग्स के लिए, nआउटपुट के पहले अक्षर ऑर्डिनल द्वारा सॉर्ट किए गए प्रत्येक इनपुट के पहले वर्ण होंगे, आउटपुट के दूसरे nवर्ण ऑर्डिनल द्वारा सॉर्ट किए गए प्रत्येक इनपुट के दूसरे वर्ण होंगे, और इसी तरह पर। आप मान सकते हैं कि तार सभी समान लंबाई के हैं, और यह कि कम से कम एक स्ट्रिंग होगी। सभी तार केवल ASCII प्रिंट करने योग्य वर्ण (32-127 अध्यादेश) से बने होंगे।

पायथन में संदर्भ कार्यान्वयन ( इसे ऑनलाइन आज़माएं ):

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

उदाहरण:

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

नियम

  • मानक खामियों को मना किया जाता है
  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से लीडरबोर्ड उत्पन्न करता है) a) प्रति भाषा सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

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

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक स्कोर अंतिम संख्या है:

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

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो स्निपेट में दिखाई देगा:

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

कोड स्निपेट दिखाएं

code-golf  string 
— मै जाऊं
स्रोत

जवाबों:

11

जीएस 2 , 4 बाइट्स

*Ü■/

यह STDIN से तार पढ़ता है, लाइनफीड द्वारा अलग किया जाता है।

स्रोत कोड CP437 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

परीक्षण चालन

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

यह काम किस प्रकार करता है

*       Split the input into the array of its lines.
 Ü      Zip the resulting array.
  ■     Map the rest of the program over the resulting array.
   /        Sort.
— डेनिस
स्रोत
6

हास्केल, 39 36 बाइट्स

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

प्रयोग उदाहरण: ((>>=sort).transpose) ["HELLO","world","!!!!!"]-> "!Hw!Eo!Lr!Ll!Od"।

स्ट्रिंग्स की सूची स्थानांतरित करें, sortउस पर मैप करें और स्ट्रिंग्स की परिणामी सूची को सूचीबद्ध करें ( >>=सूची के संदर्भ में है concatMap)।

— nimi
स्रोत
मैं इस के साथ आया!
— गर्वित हेकलर
मैंने नहीं; मैं सूची जैसी चीजों के लिए मोनाड उदाहरण का फायदा उठाना भूल गया। (+1)
— बैल्स्टा
5

टीस्क्रिप्ट , 9 बाइट्स

_t¡ßlp¡)µ

TeaScript में सभी सही तरीके से बिल्ट-इन सभी गलत तरीकों से लागू किया गया है।

इसे ऑनलाइन आज़माएं

Ungolfed

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

व्याख्या

_t()        // Transposes input array
    m(#     // Loops through inputs
       lp() // Sorts characters by char code
     )
j``         // Joins back into string
— Downgoat
स्रोत
@intrepidcoder मेरे लिए ठीक काम करता है। शायद आपके ब्राउज़र ने कुछ फ़ाइलों को कैश किया है? शायद आपका कैश क्लियर करने से काम चल जाए। मैं हालांकि सफारी का उपयोग कर रहा हूँ। मैं फ़ाइलों को ताज़ा करने की कोशिश करूँगा
— डाउनगोट
4

पायथन, 50 48 बाइट्स

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

-2 बाइट्स के लिए @xnor को धन्यवाद!

— डेनिस
स्रोत
4
आप "".joinएक चर के लिए बचा सकते हैं ।
— xnor
ओह, मुझे कोई पता नहीं था। धन्यवाद!
— डेनिस
3

ऑक्टेव, 15 बाइट्स

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

उदाहरण:

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

जूलिया, 46 बाइट्स

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

यह एक अनाम फ़ंक्शन बनाता है जो स्ट्रिंग की एक सरणी को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे 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
— एलेक्स ए।
स्रोत
1

मिंकोलंग 0.13 , 46 बाइट्स

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

इसे यहाँ आज़माएँ। इनपुट की उम्मीद है "HELLO""world""!!!!!"( जैसे कोई अल्पविराम)।

व्याख्या

$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
— एलेंडिया स्ट्राटन
स्रोत
1

के, 10 बाइट्स

,/{x@<x}'+

शामिल हों ( ,/) की तरह ( {x@<x}) प्रत्येक ( 'पक्षांतरित (के) +स्ट्रिंग की एक सूची के)।

कार्रवाई में:

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

सरल, लेकिन K एक एकल-वर्ण सॉर्ट फ़ंक्शन नहीं होने से यहां थोड़ी चोट लगी है और इसके बजाय ऑपरेशन को स्कैटर-इकट्ठा इंडेक्स ऑपरेटर @और एक आदिम में विभाजित किया गया है जो क्रमपरिवर्तन वेक्टर को पैदावार करता है जो एक सूची को सॉर्ट करेगा <।

— JohnE
स्रोत
1

सी ++ 14, 152 बाइट्स

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

मानचित्र + ज़िप के किसी भी लाभ का उपयोग नहीं (अनुमान क्यों)

अधूरा + उपयोग

#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
स्रोत
1

गणितज्ञ, 51 बाइट्स

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

Mathematica में स्ट्रिंग हेरफेर महंगा है ...

— LegionMammal978
स्रोत
1

PHP ,92 91 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मुझे विश्वास है कि यह PHP के अंतर्निहित सरणी फ़ंक्शंस का उपयोग न करके कम किया जा सकता है, लेकिन कोशिश करनी थी!

या 85 बाइट्स

@ रात 2 के झूले, PHP के अंतर्निहित सरणी कार्यों का उपयोग करने की कोशिश नहीं करने से छोटा किया गया:

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

इसे ऑनलाइन आज़माएं!

— 640KB
स्रोत
@ रात 2 अच्छी तरह से किया! आपको उस पोस्ट को अपना होना चाहिए। यह बहुत बुरा है जो array_columnतार के एक सरणी पर काम नहीं करेगा अन्यथा यह CG के लिए काफी अधिक उपयोगी होगा। और बेशक छोड़ना $argv[0]हमेशा एक दर्द होता है ...
— 640KB
0

क्लोजर / क्लोजुरस्क्रिप्ट, 43 बाइट्स

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

एक अनाम फ़ंक्शन बनाता है। एक ClojueScript REPL में लिखा है, भी मान्य Clojure होना चाहिए।

इसे यहां दर्ज करें , फिर कॉल करें (*1 ["HELLO" "world" "!!!!!"])। या करते हैं (def f *1)और फिर उपयोग करते हैं (f ["abc" "cba"])।

— MattPutnam
स्रोत
0

सीलोन, 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)};

जबकि सीलोन का एक zipकार्य है , यह उनमें से चलने के बजाय केवल दो पुनरावृत्तियों लेता है। unzipदूसरी ओर, ट्यूपल्स के चलने योग्य लेता है, और मैं अपने तारों को ट्यूपल्स में बदलना नहीं चाहता। इसलिए मैंने अपना स्वयं का ट्रांज़ोज़ फ़ंक्शन लागू किया, जो हास्केल कार्यान्वयन से प्रेरित था, जो Google ने मेरे लिए कहीं और पाया ।

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

के प्रकारों को nऔर tअधिक सामान्य रूप से परिभाषित किया जा सकता है, लेकिन यह कोडगुल्फ़ ;-) है ( nजो मैंने assertNarrowदो सप्ताह के रूप में प्रस्तावित किया है उसका एक विशेष मामला है )।

— पाओलो एबरमन
स्रोत
0

पर्ल 6 , 33 बाइट्स

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

उदाहरण का उपयोग:

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)
— ब्रैड गिल्बर्ट b2gills
स्रोत
0

जेली , 3 बाइट्स

ZṢ€

इसे ऑनलाइन आज़माएं!

केवल एक पूर्ण कार्यक्रम के रूप में माना जाता है तो मान्य : परिणामी मूल्य स्ट्रिंग्स की एक सूची है, लेकिन जब यह मुद्रित होता है तो जेली स्पष्ट रूप से इसे समतल करती है ।

  €    Map
 Ṣ     sort
Z      over the columns of the input.
— असंबंधित स्ट्रिंग
स्रोत
0

स्टैक्स , 5 बाइट्स

LMFop

तो LMNOP के करीब :(

भागो और इसे staxlang.xyz पर डीबग करें!

सभी इनपुट को स्ट्रिंग्स की एक सूची में डालें ( L), और इस सूची को स्थानांतरित करें ( M)। प्रत्येक परिणामी स्ट्रिंग ( F), सॉर्ट ( o) और प्रिंट ( p) के लिए।

— खुल्द्रेसथ न’बैरी
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.