पहचान

इसलिए मैं अपना समय बर्बाद कर रहा हूं फिर से प्रत्यय छंटाई एल्गोरिदम पर शोध कर रहा हूं, हाथ से और कोड में नए विचारों का मूल्यांकन कर रहा हूं। लेकिन मैं हमेशा अपने प्रत्ययों के प्रकार को याद रखने के लिए संघर्ष करता हूँ! क्या आप बता सकते हैं कि मेरे प्रत्यय किस प्रकार के हैं?

वामपंथी-सबसे क्या?

बहुत सारे प्रत्यय एल्गोरिदम (एसएआईएस, केए, मेरे अपने डावरे) समूह को क्रमबद्ध करने के लिए विभिन्न प्रकारों में प्रत्यय लगाते हैं। दो बुनियादी प्रकार हैं: एस-प्रकार और एल-टाइप प्रत्यय। एस-टाइप प्रत्यय वे प्रत्यय हैं जो लेक्सिकोग्राफिक रूप से कम ( एस मॉलर) निम्न प्रत्यय की तुलना में कम होते हैं और एल-टाइप अगर यह लेक्सिकोग्राफिक रूप से अधिक ( एल एगर) है। एक बाएं-सबसे एस-प्रकार ( एलएमएस-प्रकार ) बस इतना है: एक एस-टाइप प्रत्यय जो एल-टाइप प्रत्यय से पहले है ।

इन एलएमएस-प्रकार के प्रत्ययों के बारे में विशेष बात यह है कि एक बार जब हम उन्हें हल करते हैं तो हम रैखिक समय में अन्य सभी प्रत्ययों को क्रमबद्ध कर सकते हैं! है ना कमाल?

चुनौती

एक स्ट्रिंग को देखते हुए यह एक विशेष चरित्र द्वारा समाप्त किया जाता है जो उस स्ट्रिंग में किसी भी अन्य चरित्र से कम है (उदाहरण के लिए, नल से भी छोटा)। प्रत्येक प्रत्यय के लिए एक प्रकार का संक्षारक चार आउटपुट।

आप स्वतंत्र रूप से जो चार जो प्रकार के लिए उपयोग करने के लिए चुन सकते हैं, लेकिन मैं पसंद करते हैं L, S and *के लिए L-, S- and LMS-typeजब तक वे कर रहे हैं के रूप में सभी प्रिंट करने योग्य ( 0x20 - 0x7E)।

उदाहरण

स्ट्रिंग mmiissiissiippiआउटपुट को देखते हुए (उपयोग करते समय L, S and *):

 LL*SLL*SLL*SLLL

उदाहरण के लिए पहले Lइस तथ्य के कारण है कि mmiissiissiippi$लेक्सिकोग्राफिक रूप से अधिक है miissiissiippi$( $जोड़ा गया न्यूनतम चरित्र का प्रतिनिधित्व करता है):

L - mmiissiissiippi$ > miissiissiippi$
L - miissiissiippi$  > iissiissiippi$
* - iissiissiippi$   < issiissiippi     and preceeded by L
S - issiissiippi$    < ssiissiippi$
L - ssiissiippi$     > siissiippi$
L - siissiippi$      > iissiippi$
* - iissiippi$       < issiippi$        and preceeded by L
S - issiippi$        < ssiippi$
L - ssiippi$         > siippi$
L - siippi$          > iippi$
* - iippi$           < ippi$            and preceeded by L
S - ippi$            < ppi$
L - ppi$             > pi$
L - pi$              > i$
L - i$               > $

कुछ और उदाहरण:

"hello world" -> "L*SSL*L*LLL"
"Hello World" -> "SSSSL*SSLLL"
"53Ab§%5qS"   -> "L*SSL*SLL"

लक्ष्य

मैं पीटर कॉर्डेस को परेशान करने के लिए यहाँ नहीं हूं (मैं कुछ समय में स्टैकओवरफ़्लो पर ऐसा करने जा रहा हूं); मैं बहुत आलसी हूँ इसलिए यह कोर्स कोड-गोल्फ है ! बाइट्स जीत में सबसे छोटा जवाब।

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

Edit2: जैसा कि टिप्पणियों में कहा गया है कि आउटपुट प्रत्येक इनपुट चरित्र के लिए एक एकल वर्ण होना चाहिए। जबकि मैंने यह मान लिया था कि इसे "रिटर्न ए स्ट्रिंग" के रूप में समझा जाएगा, ऐसा लगता है कि कम से कम 1 उत्तर एकल पात्रों की सूची देता है। मौजूदा उत्तरों को अमान्य न करने के लिए, मैं आपको एकल वर्णों (या पूर्णांकों की सूची, जो केवल परिणाम या छपने पर मुद्रित होता है) को वापस करने की अनुमति दूंगा।

रैखिक समय के लिए युक्तियाँ:

यह 2 समानांतर फॉरवर्ड पुनरावृत्तियों में या एकल पिछड़े पुनरावृत्ति में किया जा सकता है।
प्रत्येक प्रत्यय की स्थिति केवल पहले 2 वर्णों पर और दूसरी प्रकार पर निर्भर करती है।
इनपुट को रिवर्स दिशा में स्कैन करना आप एल या एस को इस तरह निर्धारित कर सकते हैं: $t=$c<=>$d?:$t(पीएचपी 7), जहां पिछले और पिछले प्रकार $cका वर्तमान चार्ट $dहै $t।
मेरा PHP उत्तर देखें । कल मैं इनाम का पुरस्कार दूंगा।

code-golf string sorting

— क्रिस्टोफ
स्रोत

यह मेरा पहला सवाल है :) सैंडबॉक्स को दो अपवॉट्स मिले और कोई टिप्पणी नहीं, इसलिए मुझे लगता है कि यह पोस्ट करने के लिए तैयार है। सुझाव देने के लिए स्वतंत्र महसूस करें!

— क्रिस्टोफ

इनपुट में कौन से वर्ण दिखाई दे सकते हैं?

— मार्टिन एंडर

@MartinEnder अपने स्ट्रिंग का समर्थन करता है जैसे c++स्टाइल स्ट्रिंग्स के लिए नल बाइट । इसे बाइनरी डेटा के रूप में सोचें।

— क्रिस्टोफ

क्या *मतलब है?

— लीक नून

@LeakyNun का *अर्थ है कि संबंधित प्रत्यय प्रकार का है left most s-type। A S-type suffix that is preceeded by a L-type suffix.।

— क्रिस्टोफ

7

हास्केल , 64 53 48 42 बाइट्स

(0!)
k!(x:y)|x:y>y=1:2!y|2>1=k:0!y
_![]=[]

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

Ungolfed, साथ Charके बजाय Int:

suffixes :: String -> String
suffixes = go 'S'
 where
   go :: Char -> String -> String
   go _ "" = ""
   go lorstar s | s > tail s = 'L' : go '*' (tail s)
                | otherwise  = lorstar : go 'S' (tail s)

— bartavelle
स्रोत

बेनामी कार्यों की अनुमति है, इसलिए z=हटाया जा सकता है।

— अर्जन जोहानसन

मैं बस हास्केल नहीं पढ़ सकता। क्या आप मुझे एक संक्षिप्त विवरण देना चाहेंगे?

— क्रिस्टोफ

1

@Christoph: goफ़ंक्शन दो तर्क लेता है। पहला चरित्र है जो यह दर्शाता है कि Sस्थिति का वर्णन करने के लिए क्या उपयोग किया जाना चाहिए । दूसरा एक तार है। यह उस स्ट्रिंग के माध्यम से पुनरावर्ती रूप से जाता है, प्रत्येक चरण पर पहला वर्ण हटाता है (यही वह tailहै)। चाल यह है कि पहला तर्क *तब सेट किया जाता है जब पिछला परिणाम ए L, या Sअन्यथा था। इस तरह, उस मामले में जहां *या एक Sका उपयोग किया जाना चाहिए, उस पहले तर्क को सीधे इस्तेमाल किया जा सकता है। आशा है कि समझ में आता है।

— बर्तवेल्ले

यह एक अच्छा विचार है! मैं अधिक चतुर विचारों को देखने की उम्मीद कर रहा हूं :)

— क्रिस्टोफ

@ TorjanJohansen मैं टीआईओ में परिणाम कैसे तैयार करने वाला हूं?

— बर्तवेल्ले

6

जेली , 25 23 21 20 19 बाइट्स

Ṛ;\UỤỤIṠµI2n×ịØDṚ;0

एक पूर्ण कार्यक्रम, जो वर्णों की सूची प्रिंट करता है, का उपयोग करते हुए:

L: 0
S: 8
*: 9

(एक लिंक के रूप में यह एक सूची देता है जहां सभी आइटम पिछले एक को छोड़कर वर्ण हैं, जो एक शून्य है।)

इसे ऑनलाइन आज़माएं! या परीक्षण सूट (रूपांतरण के साथLS*) देखें।

कैसे?

Ṛ;\UỤỤIṠµI2n×ịØDṚ;0 - Link: list of characters, s  e.g. "cast"
Ṛ                   - reverse                           "tsac"
  \                 - cumulative reduce by:
 ;                  -   concatenation                   ["t","ts","tsa","tsac"]
   U                - upend (reverse each)              ["t","st","ast","cast"] (suffixes)
    Ụ               - sort indexes by value             [3,4,2,1] (lexicographical order)
     Ụ              - sort indexes by value             [4,3,1,2] (order of that)
      I             - incremental differences           [-1,-2,1] (change)
       Ṡ            - sign                              [-1,-1,1] (comparisons)
        µ           - monadic chain separation, call that x
         I          - incremental differences           [0,2] (only (-1,1) produce 2s)
          2         - literal 2                         2
           n        - not equal?                        [1,0] (indexes of * will be 0)
            ×       - multiply by x (vectorises)        [-1,0,1] (make indexes of *s 0)
              ØD    - decimal yield                     "0123456789"
             ị      - index into (1-indexed & modular)  ['8','9','0']
                Ṛ   - reverse                           ['0','9','8']
                 ;0 - concatenate a zero                ['0','9','8',0]
                    - implicit print                     0980
                    -                              i.e. "L*SL"

— जोनाथन एलन
स्रोत

क्या आप मेरे लिए एक छोटी सी व्याख्या जोड़ना चाहेंगे?

— क्रिस्टोफ

2

मैं निश्चित रूप से करूंगा - मैं पहले संभावित गोल्फों के बारे में सोच रहा हूं ...

— जोनाथन एलन

17 बाइट्स

— लीकी नून

@LeakyNun आप कैसे काम करते हो? आप एक बग का उपयोग कर रहे हैं, मुझे लगता है कि +स्ट्रिंग पर वेक्टर लग रहा है, लेकिन अंतर्निहित परिणाम वास्तव में जेली पुनरावृत्तियों नहीं हैं। तार (!) (जैसे प्रयास +@/L€या +@/L€€या ...)

— जोनाथन एलन

@JonathanAllan हाँ, +वास्तविक स्ट्रिंग पैदा करता है। यह एक अनिर्दिष्ट सुविधा है, या जिसे आप बग कहते हैं।

— लीक नून

3

पायथन 3, 92 87 74 69 65 बाइट्स

s=input()
c=1
while s:d=s<s[1:];print(d+(c<d),end='');s=s[1:];c=d

के 0लिए L, के 1लिए S, और के 2लिए उपयोग करता है *। कोट वर्णों में इनपुट स्ट्रिंग लपेटें; मेरा मानना है कि यह सम्मेलन की अनुमति है।

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

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

mmiissiissiippi
002100210021000

बचाया 5 बाइट्स लीक नून के लिए, 4 बाइट्स ओव्स के लिए धन्यवाद

— L3viathan
स्रोत

1

69 बाइट्स

— लीकी नून

1

इसे पायथन 3 के साथ 65 बाइट्स तक छोटा किया जा सकता है

— अंडा

3

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

f=(c,d)=>c&&(d<(d=c<(c=c.slice(1))))+d+f(c,d)

@ बाइल के लिए 6 बाइट्स को सहेजा गया।

व्यायाम के लिए एक पुनरावर्ती समाधान।

f=(c,d)=>c&&(d<(d=c<(c=c.slice(1))))+d+f(c,d)

console.log(f('mmiissiissiippi')); //LL*SLL*SLL*SLLL   002100210021000
console.log(f('hello world'));     //L*SSL*L*LLL       02110202000
console.log(f('Hello World'));     //SSSSL*SSLLL       11110211000
console.log(f('53Ab§%5qS'));       //L*SSL*SLL         021102100

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

6 बाइट्स बचाएं:f=(c,d)=>c&&(d<(d=c<(c=c.slice(1))))+d+f(c,d)

— नील

धन्यवाद, @ नील, मुझे पता था कि वहाँ कहीं न कहीं एक अनुकूलन होना चाहिए।

— रिक हिचकॉक

2

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

f=
s=>s.replace(/./g,_=>(c<(c=s<(s=s.slice(1))))+c,c=1)

<input oninput=o.textContent=f(this.value)><pre id=o>

स्निपेट का विस्तार करें

@ L3viathan के उत्तर का पोर्ट।

— नील
स्रोत

1

@RickHitchcock ओह, किसी भी तरह मैं बंदरगाह में कामयाब c=1के रूप में c=0...

— नील

1

सी (क्लैंग) , 88 बाइट्स

S(S,A,I)char*S,*A;{for(;strlen(S);A=S,S++,printf("%c",I=strcmp(A,S)>0?76:I==76?42:83));}

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

— आर। कप
स्रोत

80 बाइट्स

— सीलिंगकैट

1

हास्केल , 77 75 बाइट्स, रैखिक समय

f(a:b:c)|let g"L"|a<b="SL";g"S"|a>b="L*";g d=d++d;d:e=f$b:c=g[d]++e
f _="L"

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

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

यह स्ट्रिंग की शुरुआत से एक बार में एक वर्ण को अलग करना, पुनरावृत्ति का उपयोग करता है। (हास्केल स्ट्रिंग प्रकार पात्रों की एक एकल-लिंक्ड सूची है, इसलिए इनमें से प्रत्येक चरण निरंतर-समय है।)

एक तार के लिए एबीसी के लिए जहां ए और बी एकल वर्ण हैं और सी किसी भी (संभवतः खाली) स्ट्रिंग है,
- एफ ( एबीसी ) = एसएल ई , यदि एफ ( bc ) = L e और a < b ;
- एफ ( एबीसी ) = एल * ई , अगर एफ ( bc ) = S e और a > b ;
- f ( abc ) = LL ई , यदि एफ ( बीसी ) = एल ई और एक ≥ ख ;
- एफ ( एबीसी ) = एसएस ई , अगर एफ ( बीसी) ) = एस ई और एक ≤ ख ।
एकल-वर्ण स्ट्रिंग a , f के लिए ( a ) = L के लिए।

— एंडर्स कसीगोर
स्रोत

1

क्या आप कृपया स्पष्टीकरण दे सकते हैं?

— आर। काप

कृपया विवरण दें ताकि मैं यह सूचित कर सकूं कि यह रैखिक समय में चलता है।

— क्रिस्टोफ

@ क्रिसटोफ़ जोड़ा गया।

— एंडर्स कासोर्ग

@AndersKaseorg जोड़ने के लिए धन्यवाद! अफसोस की बात यह है कि अन्य हास्केल जवाब की तुलना में यह काफी क्रियात्मक है। क्या इसका उपयोग नहीं करने से आगे गोल्फ हो सकता है S, L and *?

— क्रिस्टोफ

1

@Christoph स्पष्ट होने के [1,1,2,0,1,1,2,0,1,1,2,0,1,1,1]लिए, एकल अंकों की एक सूची है, न कि एकल वर्णों की सूची। मेरे मामले में, मुझे लगता है कि संख्याओं की सूची का उत्पादन मुझे किसी भी बाइट से नहीं बचाएगा।

— एंडर्स कासोर्ग

1

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

पुनरावर्ती संस्करण के आधार पर, L3viathan का जवाब , का उपयोग कर 012के रूप में LS*:

def g(s,d=2):c=s<s[1:];return s and`c+(d<c)`+g(s[1:],c)

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

अजगर ३ , 65 59 बाइट्स

पुनरावर्ती समाधान का उपयोग कर L, Sऔर* :

f=lambda s:s and('LS'[s<s[1:]]+f(s[1:])).replace('LS','L*')

सामने से स्ट्रिंग के माध्यम से चलता है, और सभी उदाहरणों को बदलता है LS के साथL*

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

— TFeld
स्रोत

1

blah if s else''→ s and blahछह बाइट्स बचाता है। पायथन 2 में, str(blah)→ `blah`दूसरे समाधान पर एक और तीन बाइट्स बचाता है।

— एंडर्स केसॉर्ग

1

PHP, 82 बाइट, रैखिक समय

for($a=$argn;a&$c=$a[$i-=1];$d=$c)$a[$i]=2+$t=$d<=>$c?:$t;echo strtr($a,[13=>12]);

दाएं से बाएं इनपुट पर चलता है और प्रत्येक चर को प्रकार के साथ बदलता है।

$t=$d<=>$c?:$t

वर्तमान और पिछले चार (-1 या 1) दिए गए प्रकार की गणना करता है। यदि समान प्रकार नहीं बदलता है।

— क्रिस्टोफ
स्रोत

विचार के लिए +1strtr

— Jörg Hülsermann

1

PHP , 70 बाइट्स

एल = 1, एस = 0, * = 2

इसके बजाय §+3 बाइट्स के साथ अंतिम टेस्टकेस के लिए मल्टीबाइट समर्थन की आवश्यकता हैmb_substrsubstr

for(;$s=&$argn;$s=$u)$r.=$l=($l&1)+(1&$l^($s>$u=substr($s,1)));echo$r;

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

PHP , 71 बाइट्स

एल = 1, एस = 0, * = 2

for(;$s=&$argn;$s=$u)$r.=+($s>$u=substr($s,1));echo strtr($r,[10=>12]);

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

PHP , 74 बाइट्स

for(;$s=&$argn;$s=$u)$r.=SL[$s>$u=substr($s,1)];echo strtr($r,[LS=>"L*"]);

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

— जार्ग हुल्सरमन
स्रोत

$s=&$argnअत्यंत चालाक ! मुझे पूरा यकीन है कि वहाँ एक बेहतर जवाब है;) उम्मीद है कि कोई इसके साथ आता है :)

— क्रिस्टोफ

@ क्रिसटोफ मुझे लगता है कि मुझे कुछ याद आ रहा है। मेरे पास अंतिम एलएस * को एक वैरिएबल में संग्रहीत करने की कोशिश है लेकिन यह अधिक लंबा है

— जार्ज ह्यूल्सरमैन

@Christoph तुम ऐसा मतलब है? मैं वास्तव में नहीं देखा कि अंतिम टेस्टकेस गलत क्यों है, इसे ऑनलाइन आज़माएं!

— जोर्ग हल्सरमन ने

@Christoph ठीक है, मैंने देखा है कि यह अंतिम टेस्टकेस के लिए काम नहीं करता है, mb_substrइसके बजाय मुझे इसका उपयोग करना चाहिए substrयदि इनपुट सरल एससीआई सीमा में नहीं है। क्या अंतिम टेस्टकेस का समर्थन करना आवश्यक है?

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

1

@Christoph शुक्रिया इस मामले में मैं आखिरी §

— टेस्टकेस को