बेकार पात्रों को छाँटिए

Question

यह चुनौती TidB के इस बहुत अच्छे जवाब से प्रेरित है।

---

TidB के उत्तर में, प्रत्येक आठ वर्ण सही क्रम में है: gnilwoB edoC( Code Bowlingपीछे की ओर)। अन्य तार तथापि रहे हैं एक अजीब, यादृच्छिक क्रम में थे।

इसे ठीक करना आपकी चुनौती है।

nइनपुट के रूप में एक (गैर-खाली) स्ट्रिंग और एक सकारात्मक पूर्णांक लें । स्ट्रिंग में श्रेणी में ASCII वर्ण होंगे: 32-126 (टिल्ड के लिए स्थान)।

आपको स्ट्रिंग को आरोही क्रम में क्रमबद्ध करना होगा (बाईं ओर से देखा, ASCII- कोड मूल्य के आधार पर), लेकिन nस्ट्रिंग के अंत से शुरू होकर प्रत्येक वें वर्ण को छोड़ दें । एक उदाहरण के रूप में, हम स्ट्रिंग abcdABC123को इनपुट के रूप में लेते हैं , और n=4फिर हम प्राप्त करेंगे:

abcdABC123   <- Input string. (n=4)
_b___B___3   <- These will not be sorted (every 4th starting from the end)
1_2AC_acd_   <- The remaining characters, sorted
1b2ACBacd3   <- The final string (the output)

एक और उदाहरण:

9876543210   <- Input string (n=2)
_8_6_4_2_0   <- These will not be sorted
1_3_5_7_9_   <- The remaining characters, sorted
1836547290   <- The final string (the output)

इनपुट स्ट्रिंग को एक वैकल्पिक प्रारूप (स्ट्रिंग, वर्णों की सूची, एकल वर्ण तार की सूची ...) पर लिया जा सकता है। इनपुट पूर्णांक को एक वैकल्पिक प्रारूप पर भी लिया जा सकता है।

परीक्षण के मामलों:

प्रारूप होगा n=__, इसके बाद अगली पंक्ति पर इनपुट स्ट्रिंग होगी। आउटपुट नीचे लाइन पर है।

n=1   (All elements will stay in place)
nafgaksa1252#"%#
nafgaksa1252#"%#    

n=214  (The last character will stay in place. All other are sorted. 
&/lpfAVD
&/AVflpD  

n=8
g7L9T E^n I{><#ki XSj!uhl y= N+|wA}Y~Gm&o?'cZPD2Ba,RFJs% V5U.W;1e  0_zM/d$bH`@vKoQ 43Oq*C
g       n !#$%&'i*+,./01l234579;w<=>?@ADoEFGHIJKBLMNOPQR STUVWXYeZ^_`abcdhjkmqsuovyz{|}~C

Answer 1

MATL , 15 14 बाइट्स

ttfiX\qgP)S5M(

इनपुट एकल उद्धरण और एक संख्या में संलग्न एक स्ट्रिंग हैं। स्ट्रिंग में एकल-उद्धरण प्रतीकों को डुप्लिकेट (MATLAB और ऑक्टेव के रूप में) से बच जाना चाहिए।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

आदानों पर विचार करें 'abcdABC123'और 4।

tt     % Implicitly input string. Duplicate twice
       % STACK: 'abcdABC123', 'abcdABC123', 'abcdABC123'
f      % Find: indices of nonzero elements: gives [1 2 ... n] where n is input length
       % STACK: 'abcdABC123', 'abcdABC123', [1 2 3 4 5 6 7 8 9 10]
i      % Input n
       % STACK: 'abcdABC123', 'abcdABC123', [1 2 3 4 5 6 7 8 9 10], 4
X\     % 1-based modulo
       % STACK: 'abcdABC123', 'abcdABC123', [1 2 3 4 1 2 3 4 1 2 3 4]
qg     % Subtract 1, convert to logical: gives true (1) for 1, false (0) otherwise
       % STACK: 'abcdABC123', 'abcdABC123', [0 1 1 1 0 1 1 1 0 1]
P      % Flip
       % STACK: 'abcdABC123', 'abcdABC123', [1 0 1 1 1 0 1 1 1 0]
)      % Use as logical index into the string
       % STACK: 'abcdABC123', 'acdAC12'
S      % Sort
       % STACK: 'abcdABC123', '12ACacd'
5M     % Push logical index again
       % STACK: 'abcdABC123', '12ACacd', [1 0 1 1 1 0 1 1 1 0]
(      % Write into original string as specified by the index. Implicitly display
       % STACK: 1b2ACBacd3

1-आधारित मोडुलो का मतलब है कि सामान्य (0-आधारित) के बजाय mod([1 2 3 4 5], 3)देता है । मामले को पर्याप्त रूप से संभालने के लिए यहां इसकी आवश्यकता है ।[1 2 3 1 2][1 2 0 1 2]n=1

Comments

काश 05AB1E की वह आखिरी आज्ञा होती ...

— mbomb007

Answer 2

PHP, 101 बाइट्स

नकारात्मक स्ट्रिंग इंडेक्स (PHP 7.1) 21 बाइट्स बचाते हैं - और संभवतः दिन:

for([,$s,$n]=$argv;a&$c=$s[$i-=1];)$i%$n+1?$a[]=$c:0;for(sort($a);++$i;)echo$i%$n+1?$a[+$k++]:$s[$i];

के साथ भागो php -nr '<code>' '<string>' <N>।

टूट - फूट

for([,$s,$n]=$argv;     # import command line arguments to $s and $n
    a&$c=$s[$i-=1];)    # loop backward through string
    $i%$n+1?$a[]=$c:0;      # if index is not n-th, copy character to array
for(sort($a);           # sort array
    ++$i;)              # loop forward through string:
    echo$i%$n+1             # if index is not n-th
        ?$a[+$k++]              # print character from array
        :$s[$i]                 # else print character from string
    ;

Comments

क्यों $i-=1और क्या नहीं $i--?

— जोर्ज हल्सरमैन

@ JörgHülsermann क्योंकि $i--अगर काम नहीं करता $iहै NULL।

— टाइटस

@ JörgHülsermann ... और --$i, जिसकी मुझे आवश्यकता नहीं है। ;)

— टाइटस

मैंने इससे पहले कभी कोशिश नहीं की। आपके उत्तर के लिए धन्यवाद

— Jörg Hülsermann

Answer 3

ऑक्टेव , 65 54 बाइट्स

function s=f(s,n)
l=~~s;l(end:-n:1)=0;s(l)=sort(s(l));

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

'निश्चित' और 'क्रमबद्ध' वर्णों की एक सरणी बनाने के लिए तार्किक अनुक्रमण का उपयोग करता है। स्पष्टीकरण:

function s=f(s,n) % Create a function, taking a string `s` and the number `n`; the output is also named `s`.
l=~~s;             % Create logical array with the same size of the input string 
                  %    [equivalent to much more verbose true(size(s))].
l(end:-n:1)=0;    % Set the 'fixed' character positions. MATLAB/Octave automatically produces
                  %    the correct result even if n is larger than the string length.
s(l)=sort(s(l)) % Select the elements from `s` where `l` is true. Sort, and store in the corresponding positions in `s`.

जिस तरह से मैं बनाया lकी आवश्यकता है कि sअशून्य है, जो मुझे लगता है कि एक उचित आवश्यकता है, कई भाषाओं का उपयोग के रूप में \0एक अंत के स्ट्रिंग परिसीमक के रूप में।

Comments

यदि आप बाईपास करते हैं lऔर सीधे इंडेक्स नंबरों के वेक्टर का उपयोग करते हैं, तो आप कुछ बाइट्स बचा सकते हैं

— लियो

@Leo meta.codegolf.stackexchange.com/questions/11710/…

— Sanchises

@ लिओ, क्या आपका सुझाव 8 बाइट्स लंबा नहीं है?

— स्टिव ग्रिफिन

@StewieGriffin हूप्स, मैंने अद्यतन समाधान नहीं देखा

— लियो

Answer 4

पायथन 2, 191 बाइट्स

हाँ, मुझे यकीन है कि यह एक भयानक समाधान है।

n,s=input()
s=s[::-1]
R=range(len(s)/n+1)
J=''.join
k=s[::n]
t=J(sorted(J(s[i*n+1:i*n+n]for i in R)))
n-=1
print J(j[::-1]for i in zip(k,[t[::-1][i*n:i*n+n][::-1]for i in R])for j in i)[::-1]

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

मैं इसे समझाने की जहमत नहीं उठाने वाला। यह तब तक ठीक था जब तक मुझे एहसास नहीं हुआ कि इसे अंत से अनुक्रमित करने की आवश्यकता है। अब यह एक राक्षस है। इस बिंदु पर, मुझे खुशी है कि यह काम करता है।

Comments

"स्पष्टीकरण" के कारण अपवित्र। : पी

— स्टेवी ग्रिफिन

Answer 5

जावास्क्रिप्ट (ईएस 6), 100 93 बाइट्स

करी सिंटैक्स में इनपुट लेता है (s)(n)।

s=>n=>s.replace(/./g,(c,i)=>(F=_=>(s.length-++i)%n)()?[...s].filter(F,i=0).sort()[j++]:c,j=0)

प्रारूपित और टिप्पणी की गई

s => n => s.replace(        // given a string s and an integer n
  /./g,                     // for each character c of s
  (c, i) => (               // at position i:
    F = _ =>                //   F = function that tests whether the
      (s.length - ++i) % n  //       character at position i is non-static
  )()                       //   call F() on the current position
  ?                         //   if the current character is non-static:
    [...s].filter(F, i = 0) //     get the list of non-static characters
      F, i = 0              //     by filtering all characters in s with F()
    )                       //
    .sort()[j++]            //     sort them and pick the next occurrence
  :                         //   else:
    c,                      //     let c unchanged
  j = 0                     //   initialize j = non-static character pointer
)                           //

परीक्षण के मामलों

let f =

s=>n=>s.replace(/./g,(c,i)=>(F=_=>(s.length-++i)%n)()?[...s].filter(F,i=0).sort()[j++]:c,j=0)

console.log(f("abcdABC123")(4))
console.log(f('nafgaksa1252#"%#')(1))
console.log(f('&/lpfAVD')(214))
console.log(f("g7L9T E^n I{><#ki XSj!uhl y= N+|wA}Y~Gm&o?'cZPD2Ba,RFJs% V5U.W;1e  0_zM/d$bH`@vKoQ 43Oq*C")(8))

Answer 6

पर्ल 5 , 94 बाइट्स

कोड + -F -plझंडे के 88 बाइट्स ।

$_=join"",(map{(--$i%$n?"":$F[$#F-$i--]),$_}sort grep$i++%$n,reverse@F),chop if($n=<>)>1

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

यह मेरी राय में बहुत लंबा है, लेकिन पहले से ही वह बदसूरत नहीं है ... मैं अभी भी इसे और भी आगे बढ़ाने की कोशिश कर रहा हूं।

Answer 7

जेली , 14  13 बाइट्स

FṢṁ
ṚsṚµḢ€ż@Ç

पूर्ण कार्यक्रम जो स्ट्रिंग को STD से बाहर प्रिंट करता है *।

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

कैसे?

ṚsṚµḢ€ż@Ç - Main link: string s, non-negative number n
Ṛ         - reverse s
 s        - split into chunks of size n
  Ṛ       - reverse the resulting list
   µ      - monadic chain separation (call that list x)
    Ḣ€    - head €ach - yield a list of the first entries of each of x and modify x
        Ç - call the last link (1) as a monad - get the sorted and re-split list
      ż@  - zip together (with reversed @rguments)

FṢṁ - link 1, sort and reshape like self: list of lists
F   - flatten into a single list
 Ṣ  - sort
  ṁ - mould the result like the input

मैं मदद नहीं कर सकता, लेकिन लगता है कि इस तथ्य का उपयोग करने का एक तरीका है जो Ḣइसके इनपुट को संशोधित करता है

* एक समारोह के लिए एक के साथ एक सूची में उत्पादन समतल करना चाहते हैं F।
उदाहरण के लिए "abcdABC123", 4पैदावार के
[[['1'],['b']],[['2','A','C'],['B']],[['a','c',',d'],['3']]]
बजाय:
['1','b','2','A','C','B','a','c',',d','3']

Answer 8

पायथन + न्यूमपी , 115 114 बाइट्स

from numpy import *
def f(x,n):l=len(x);x=array(x);m=[1<2]*l;m[-1::-n]=[1>2]*len(m[0::n]);x[m]=sort(x[m]);return x

इनपुट के रूप में एक नियमित पायथन सूची लेता है (यह सुनिश्चित नहीं है कि एक सरणी लेना कोषेर माना जाएगा); परिणाम सहित एक NumPy सरणी देता है।

संबंधित सूचकांकों को चिह्नित करके और बाकी को छांटकर काम करता है।

Answer 9

पायथन 2, 119 113 बाइट्स

n,l=input()
i=range(len(l))
print"".join(sorted(l[~a]for a in i if a%n)[-a+a/n]if a%n else l[~a]for a in i)[::-1]

सभी वर्णों की एक सूची बनाता है जिसे क्रमबद्ध किया जाना है, उन्हें क्रमबद्ध करना और उन्हें मुद्रण के लिए मर्ज करना है, जबकि कुछ रेग्युलरिंग के माध्यम से पीछे हटने से बचना है।

Comments

print"".join(sorted(l[~a]for a in i if a%n)[-a+a/n]if a%n else l[~a]for a in i)[::-1]5 बाइट्स बचाता है

— TidB

@TidB धन्यवाद, स्क्रॉलबार को लगभग समाप्त कर दिया! (स्पष्ट रूप से मेरी पिछली गिनती में एक अनुगामी न्यूलाइन शामिल थी, इसलिए यह 114 के बजाय अब 113 लगती है।)

— मूओईपिप

Answer 10

रूबी, 64 बाइट्स

प्रतिस्थापन और छँटाई के लिए सभी अप्रासंगिक वर्णों को हथियाने के लिए रेगेक्स का उपयोग करता है।

->i,s,j=-1{s.gsub(r=/.(?!(?=.{#{i}})*$)/){s.scan(r).sort[j+=1]}}

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