यह कार्य बल्कि सरल है, और तीन अलग-अलग "ऑपरेटर" वर्णों का उपयोग करता है। आपका काम, पत्र का एक सरल अनुक्रम दिया जाता है, का उपयोग कर इसे सांकेतिक शब्दों में बदलना करने के लिए निम्न कार्य <, >, *। आप ऊपरी या निचले अक्षरों का उपयोग करना चुन सकते हैं, आपको दोनों को संभालने की आवश्यकता नहीं है।

सिफर स्पष्टीकरण

सिफर सरल है, आप *अपने "सबमिट" फ़ंक्शन के साथ पत्र 1 से अंत पत्र तक पार करने के लिए वेतन वृद्धि और वेतन वृद्धि संचालन का उपयोग कर रहे हैं । "वेतन वृद्धि" के लिए ऑपरेटर होगा >और "वेतन वृद्धि" होगा <।

शब्द का उपयोग कर एक उदाहरण adbc:

शब्द के पहले अक्षर से शुरू करें, उस अक्षर को आउटपुट करें। a
अगला, उपयोग करें >और <(ब्रेनफक की तरह) अगले पत्र को "नेविगेट" करने के लिए। 1 से a>'बढ़ाने' के aलिए पत्र में परिणाम होगा b। a<परिणाम होगा zक्योंकि आप पत्र को कम कर रहे हैं (यह लपेटता है, आपको हमेशा उन दिशाओं का चयन करना चाहिए जिनके परिणामस्वरूप संचालन की संख्या कम हो)।
का सही minimalized संयोजन outputting के बाद <और >उत्पादन एक *निरूपित करने के लिए है कि हम अगले पत्र पहुँच गए हैं।

सांकेतिक शब्दों में बदलना adbcहोगा:

a          # a
a>>>*      # ad
a>>>*<<*   # adb
a>>>*<<*>* # adbc

उदाहरण

सांकेतिक शब्दों में बदलना azaहोगा:

a       # a
a<*     # az
a<*>*   # aza

और ज्यादा उदाहरण:

"abcdef"    =  "a>*>*>*>*>*"
"zyaf"      =  "z<*>>*>>>>>*"
"zzzzzz"    =  "z*****"
"z"         =  "z"
"zm"        =  "z<<<<<<<<<<<<<*" or "z>>>>>>>>>>>>>*" (equidistant)
"zl"        =  "z>>>>>>>>>>>>*"
"alphabet"  =  "a>>>>>>>>>>>*>>>>*<<<<<<<<*<<<<<<<*>*>>>*<<<<<<<<<<<*"
"banana"    =  "b<*>>>>>>>>>>>>>*<<<<<<<<<<<<<*>>>>>>>>>>>>>*<<<<<<<<<<<<<*" OR "b<*<<<<<<<<<<<<<*>>>>>>>>>>>>>*<<<<<<<<<<<<<*>>>>>>>>>>>>>*"
"abcdefghijklmnopqrstuvwxyz" = "a>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*>*"
"abcdefz"   =  "a>*>*>*>*>*<<<<<<*"

नियम

हम कर रहे हैं एन्कोडिंग डिकोडिंग नहीं है, इसलिए गड़बड़ नहीं है कि अप।
आप मान सकते हैं कि संदेश में पत्र [A-Z]या [a-z], आपकी पसंद होगी।
आप *ईजी (ईजी $) को दर्शाने के लिए किसी भी गैर-अक्षर / संख्यात्मक / आरक्षित चरित्र का उपयोग कर सकते हैं ।
आपके पास अंत होना चाहिए *, यह दोहराव पर निहित नहीं है।
आप मान सकते हैं कि कोई खाली स्ट्रिंग नहीं है, लेकिन एक एकल चरित्र संभव है।
यदि यह अगले अक्षर के लिए समान है, तो आप एक दिशा चुन सकते हैं।
यह कोड-गोल्फ , सबसे कम बाइट-काउंट जीत है।

कृपया अपने उत्तर की व्याख्या करें, यह दूसरों को इस तरह सीखने में मदद करता है।

code-golf cipher

— जादू ऑक्टोपस Urn
स्रोत

बस स्पष्ट होने के लिए, अंतिम परीक्षण मामला प्रतिनिधित्व करता है abcdefghijklmnopqrstuvwxyzऔर इसका अपना इनपुट नहीं है?

— निक क्लिफर्ड

1

@NickClifford हाँ।

— मैजिक ऑक्टोपस Urn

मुझे लगता है कि zlउपयोग करना चाहिए >।

— xnor

4

क्या आप कृपया उदाहरण देख सकते हैं? alphabetमेरी राय में है a>>>>>>>>>>>*>>>>*<<<<<<<<*<<<<<<<*>*>>>*<<<<<<<<<<<*और zlहोना चाहिए z>>>>>>>>>>>>*और bananaएक दूसरे समाधान मौजूद होना चाहिएb<*<<<<<<<<<<<<<*>>>>>>>>>>>>>*<<<<<<<<<<<<<*>>>>>>>>>>>>>*

— Jörg Hülsermann

@xnor सही है, से एक मैनुअल टाइपो था zm। @ जोर्ग ने अच्छे कैच लपके, ये सभी तय करते थे, एक मैनुअल प्रयास था।

— मैजिक ऑक्टोपस मूत्र

2

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

OIżN$ẋ"@€⁾><;€⁶ṭḢ

एक स्थान चरित्र का उपयोग करता है *(एक स्थान ⁶, या एक नई रेखा, ⁷एक बाइट को बचाता है ”*)।

साथ काम करता है या तो अपरकेस-केवल या केवल छोटे-इनपुट।

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

कैसे?

OIżN$ẋ"@€⁾><;€⁶ṭḢ - Main link: string s          e.g. "adbc"
O                 - cast s to ordinals                [97,100,98,99]
 I                - incremental differences           [3,-2,1]
    $             - last two links as a monad:
   N              -     negate                        [-3,2,-1]
  ż               -     zip together                  [[3,-3],[-2,2],[1,-1]]
         ⁾><      - literal ['>','<']                 "><"
      "@€         - using reversed @arguments for €ach zip with("):
     ẋ            -     repeat (-n are like zeros)    [[">>>",""],["","<<"],[">",""]]
            ;€    - concatenate €ach with:
              ⁶   -     literal ' '                   [[">>>","",' '],["","<<",' '],[">","",' ']]
               ṭ  - tack to:
                Ḣ -     head of s (1st char)          [['a'],[">>>","",' '],["","<<",' '],[">","",' ']]
                  - implicit print   (" not printed:) "a>>> << > "

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

11

8086 मशीन कोड, 70 68 67 बाइट्स

00000000  be 82 00 bf 43 01 57 31  d2 ac 3c 0d 74 2c 89 d1  |....C.W1..<.t,..|
00000010  88 c2 aa e3 f4 4f 28 c1  9f 88 e7 79 02 f6 d9 83  |.....O(....y....|
00000020  f9 0d 9f 76 05 83 e9 1a  f6 d9 30 fc 9e b0 3c 78  |...v......0...<x|
00000030  02 b0 3e f3 aa b0 2a aa  eb cf c6 05 24 b4 09 5a  |..>...*.....$..Z|
00000040  cd 21 c3                                          |.!.|
00000043

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

            |   org 0x100
            |   use16
be 82 00    |       mov si, 0x82        ; source = command line arguments
bf 43 01    |       mov di, result      ; destination = result
57          |       push di
31 d2       |       xor dx, dx          ; clear dx
ac          |   n:  lodsb               ; al = *si++
3c 0d       |       cmp al, 0x0d        ; end of input reached? (newline)
74 2c       |       je q                ; jump to exit in that case
89 d1       |   @@: mov cx, dx          ; store last char in cl
88 c2       |       mov dl, al          ; and store the current char in dl
aa          |       stosb               ; *di++ = al
e3 f4       |       jcxz n              ; skip encoding this char if cx == 0 (only happens for the first char)
4f          |       dec di              ; move di pointer back
28 c1       |       sub cl, al          ; take the difference between this char and the last one
9f          |       lahf                ; store flags from last subtraction in bh
88 e7       |       mov bh, ah
79 02       |       jns @f
f6 d9       |       neg cl              ; make sure cl is positive
83 f9 0d    |   @@: cmp cl, 13          ; which way is shorter?
9f          |       lahf                ; also store these flags
76 05       |       jbe @f
83 e9 1a    |       sub cl, 26          ; invert cl if we're going backwards
f6 d9       |       neg cl
30 fc       |   @@: xor ah, bh          ; xor saved flags together
9e          |       sahf                ; load flags register with the result
b0 3c       |       mov al, '<'
78 02       |       js @f               ; now the sign flag tells us which operator to use
b0 3e       |       mov al, '>'
f3 aa       |   @@: rep stosb           ; while (cx--) *di++ = al
b0 2a       |       mov al, '*'         ; mark the end with an asterisk
aa          |       stosb
eb cf       |       jmp n               ; repeat
c6 05 24    |   q:  mov byte [di], '$'  ; mark end of string
b4 09       |       mov ah, 0x09        ; dos function: print string
5a          |       pop dx              ; dx = string pointer
cd 21       |       int 0x21            ; syscall
c3          |       ret
            |   result rb 0

— user5434231
स्रोत

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

— मैजिक ऑक्टोपस Urn

धन्यवाद। हालांकि यह बहुत तुच्छ समाधान है। बस

— 8086

10

पायथन 3 , 87 बाइट्स

r,*s=input();p=r
for c in s:d=(ord(p)-ord(c)-13)%26-13;r+='<'*d+'>'*-d+'*';p=c
print(r)

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

लोअरकेस या अपरकेस के साथ काम करता है।

प्रोग्राम आउटपुट स्ट्रिंग बनाता है rक्योंकि यह इनपुट स्ट्रिंग में वर्णों पर पुनरावृति करता है। यह पिछले वर्ण को संग्रहीत pकरता है, और pनए वर्ण से प्राप्त करने के लिए वृद्धिशील ऑपरेशन की गणना करता है c।

पात्रों के बीच का अंतराल है ord(c)-ord(p), और (ord(c)-ord(p)-13)%26-13यह अंतराल के लिए 26 modulo लेता है [-13..12]। एक नकारात्मक परिणाम का मतलब है कि यह नीचे कदम रखने के लिए छोटा है, और एक सकारात्मक परिणाम का मतलब कदम बढ़ाना है। इसे संकेत के आधार पर >या स्ट्रिंग में परिवर्तित करने की आवश्यकता है <। उपयोग absया सशर्त करने के बजाय , हम नकारात्मक s*nहोने पर खाली स्ट्रिंग देने वाले पायथन के स्ट्रिंग गुणन का लाभ उठाते हैं n। अभिव्यक्ति में '<'*-d+'>'*d, गलत-हस्ताक्षरित हिस्सा योगदान नहीं करता है।

प्रारंभिक अवस्था को इनपुट को उसके पहले चरित्र में विभाजित करके और शेष को पायथन 3 के अनपैकिंग के साथ नियंत्रित किया जाता है r,*s=input()। प्रारंभिक चरित्र का उपयोग स्ट्रिंग का निर्माण शुरू करने के लिए किया जाता है, साथ ही प्रारंभिक "पिछले" चार।

इस अनपैकिंग को करने के लिए पायथन 3 पर स्विच करने का सुझाव देने के लिए ओवर्स का धन्यवाद।

— XNOR
स्रोत

6

पायथन 3 , 110 93 बाइट्स

r,*s=input()
b=r
for a in s:d=(ord(a)-ord(b))%26;r+=['>'*d,'<'*(26-d)][d>13]+'*';b=a
print(r)

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

— OVS
स्रोत

ऊ ... लोअर और अपरकेस दोनों के लिए काम करता है, अच्छा एक (लेकिन मुझे लगता है कि आप एक या दूसरे को मानकर बाइट्स से दाढ़ी बना सकते हैं)।

— मैजिक ऑक्टोपस Urn

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

— कॉमरेड स्पार्कलेपनी

3

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

इनपुट स्ट्रिंग केस असंवेदनशील है।

s=>s.replace(/./g,(c,i)=>(d=~~s-(s=parseInt(c,36)),i)?'<><>'[k=d/13+2|0].repeat([d+26,-d,d,26-d][k])+'*':c)

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

पाइथन के विपरीत, जेएस मोडुलो ऑपरेटर एक संख्या देता है जिसमें विभाजक के बजाय लाभांश के समान चिह्न होता है। इसके अलावा, जेएस repeat()विधि एक नकारात्मक संख्या दिए जाने पर एक त्रुटि फेंकता है, बजाय एक खाली स्ट्रिंग वापस करने के (और यह *वैसे भी एक साधारण से अधिक लंबा है )।

इस चुनौती के लिए ये प्रतिकूल व्यवहार हैं। इसलिए, हम बेहतर पहचान करेंगे कि गणित के ट्रिक्स पर भरोसा करने के बजाय हम किस सटीक मामले में हैं। (जिसका मतलब यह नहीं है कि इस तरह की चाल मौजूद नहीं है, बल्कि यह है कि मैं उन्हें खोजने में विफल रहा।)

नीचे एक तालिका है जिसमें 4 कब्जे के मामलों का वर्णन किया गया है, जहां dवर्तमान चरित्र और पिछले एक के बीच हस्ताक्षरित दूरी है:

d           | floor(d / 13) + 2 | direction | repeat
------------+-------------------+-----------+-------
-25 ... -14 |         0         |     <     | d + 26
-13 ... -1  |         1         |     >     | -d  
 +0 ... +12 |         2         |     <     | +d  
+13 ... +25 |         3         |     >     | 26 - d

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

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

let f =

s=>s.replace(/./g,(c,i)=>(d=~~s-(s=parseInt(c,36)),i)?'<><>'[k=d/13+2|0].repeat([d+26,-d,d,26-d][k])+'*':c)

console.log(f("abcdef"));
console.log(f("zyaf"));
console.log(f("zzzzzz"));
console.log(f("z"));
console.log(f("zm"));
console.log(f("zl"));
console.log(f("alphabet"));
console.log(f("banana"));
console.log(f("abcdefghijklmnopqrstuvwxyz"));
console.log(f("abcdefz"));

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

— Arnauld
स्रोत

2

PHP, 127 बाइट्स

for($l=ord($r=($s=$argn)[0]);$x=ord($s[++$i]);$l=$x)$r.=str_pad("",($a=abs($n=$l-$x))<14?$a:26-$a,"><"[$n>0^$a>13])."*";echo$r;

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

PHP, 137 बाइट्स

for($l=$r=($s=$argn)[0];$s[++$i];$l=$s[$i])$r.=str_pad("",$d=min($a=abs(ord($l)-ord($s[$i])),$b=26-$a),"><"[$d<$b^$l<$s[$i]])."*";echo$r;

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

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

2

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

f=
s=>s.replace(/./g,(c,i)=>(p=(n+26-(n=parseInt(c,36)))%26,i?'<>'[p+3>>4].repeat(p>13?26-p:p)+'*':c),n=0)

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

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

s=>[...s].map(c=>(n=parseInt(c,36),p&&(p=(n+26-p)%26,s+='><'[p+3>>4].repeat(p>13?26-p:p)+'*'),p=n),s=s[p=0])&&s

मूल रूप से संस्करण जो 111 बाइट्स लेने से पहले मैंने nकंप्यूटिंग के दौरान सेटिंग के @ अरनुल्ड की चाल को अनुकूलित किया था p, मुझे लगता है कि sइसके बजाय शायद एक और चाल है , nलेकिन यह देर हो रही है इसलिए मैं परेशान नहीं करूंगा:

— नील
स्रोत

2

हास्केल (लैम्बडाबोट), 161 153 बाइट्स

w(s:n)=s:(join.snd$mapAccumL(ap(,).g)s n);g c n|q<-[c..'z']++['a'..c],(Just l,s)<-minimum$first(elemIndex n)<$>[(q,'>'),(reverse q,'<')]=(s<$[1..l])++"*"

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

स्पष्टीकरण:

-- Encode a single letter
g c n | q          <- [c..'z']++['a'..c]        -- The alphabet starting from letter c, looping around
      , (Just l,s) <- minimum                   -- Choose the smallest of ..
                    $ first(elemIndex n)        -- the index of the letter n ..
                  <$> [(q,'>'),(reverse q,'<')] -- from the alphabet q and its reverse

      = (s<$[1..l]) -- Repeat < or > the same number of times as the index of n ..
     ++ "*"         -- and append *

-- Encode the whole string
w (s:n) = s                                -- Yield the first char of the input
        : ( join . snd                     -- Concatinate the result of ..
          $ mapAccumL (\a b->(b,g a b))s n -- executing the g function on each letter of the input string ..
                                           -- except the first, passing the previous letter as the 'c' ..
                                           -- argument on each iteration
          )

— BlackCap
स्रोत

2

एक्सेल VBA 130 बाइट्स

s="":p=Mid(s,1,1):For i=1 To Len(s)-1:b=Asc(Mid(s,i+1,1)):a=Asc(Mid(s,i,1)):p=p &String(abs(b-a),IIf(b>a,">","<"))&"*":Next:[a1]=p

इसे एक्सेल VBA तत्काल विंडो से चलाएँ।

स्पष्टीकरण:

लूप के लिए सरल है कि स्ट्रिंग फ़ंक्शन के साथ ">" या "<" की संख्या को दोहराने के लिए जहां n में i और i + 1 वर्ण स्ट्रिंग के बीच एससीआई अंतर है।

— रोहन
स्रोत

2

जावा 7-, 232 बाइट्स

class C{static void main(String[]a)throws Exception{int i=System.in.read(),j,d,c;p(i);while((j=System.in.read())>10){d=(j-i+26)%26;c=d>13?-1:1;while(d%26>0){d-=c;p(61+c);}p(42);i=j;}}static void p(int k){System.out.print((char)k);}}

बहुत तुच्छ समाधान। असंबद्ध और टिप्पणी:

class C {
    static void main(String[] a) throws Exception {
        int i = System.in.read(), j, d, c; // i is the last character. j is the current character. d is the difference. c is the direction (-1 is left, 1 is right)
        p(i); // print the starting character first
        while ((j = System.in.read()) > 10) { // keep going until a newline is hit (or an EOF/EOL for -1)
            d = (j - i + 26) % 26; // get the difference (always positive) by wrapping around
            c = d > 13 ? -1 : 1; // get the direction by finding which way is shorter, going right when it's a tie
            while (d % 26 > 0) { // keep going until the current character is reached
                d -= c; // reduce d in the right direction
                p(61 + c); // < is 60 = 61 + (-1), > is 62 = 61 - (-1)
            }
            p(42); // print an asterisk
            i = j; // set the current character to the new reference point
        }
    }

    static void p(int k) {
        System.out.print((char) k);
    }
}

— HyperNeutrino
स्रोत

2

सी, 170 बाइट्स

e(c){putchar(c);}i;m(a,b){i=b-a?a>b?b-a<14?b-a:-(a+26-b):a-b<14?-(a-b):b+26-a:0;while(i>0)e(62),i--;while(i<0)e(60),i++;}f(char*l){e(*l);while(l[1])m(*l,l[1]),e(42),l++;}

विस्तृत लाइव

e(c){ putchar(c); } // encode

g(a,b) // obtain required transition
{
    return (b-a) // calculate distance

         ? (a > b // distance is non-zero

             // if b comes after a
             ? (b-a < 14 // if forward is a shorter path
                 ? b-a // go forward
                 : -(a+26-b)) // otherwise go backward

             // if b comes before a
             : (a-b < 14 // if backward is a shorter path
                 ? -(a-b) // go backward
                 : b+26-a)) // otherwise go forward

         : 0; // if distance is 0
}

// transition
i;m(a,b)
{
    // obtain required transition
    i=g(a,b);

    // encode forward transition
    while(i>0)e('>'), i--;

    // encode backward transition
    while(i<0)e('<'),i++;
}

// incremental cipher function
f(char*l)
{
    e(*l); // encode first character

    while(*(l+1)) // while next character is not END-OF-STRING
        m(*l,*(l+1)), // do transition from current to next character
        e('*'), // encode
        l++; // next
}

— Khaled.K
स्रोत

शांत समाधान। निम्नलिखित शायद समझना आसान है, लेकिन 1 बाइट लंबी है:

#define x q<14?q:q+26 e(c){putchar(c);}i,q;m(a,b){q=b-a;i=q?(a>b?x:-x):0;while(i>0)e('>'),i--;while(i<0)e('<'),i++;}f(char*l){e(*l);while(*(l+1))m(*l,*(l+1)),e('*'),l++;}

— मोरकी

1

@Moreaki Thx, लेकिन यह एक कोड-गोल्फ है, इसलिए हम हमेशा बाइट काउंट को कम करने का लक्ष्य रखते हैं, वैसे भी मैंने अपने कोड के काम करने के तरीके पर विस्तृत विवरण जोड़ा है।

— खालिद.के।

2

जावास्क्रिप्ट (ईएस 6), 140 128 129 111 113 बाइट्स

मैं अन्य जेएस समाधानों के लिए एक अलग मार्ग नीचे चला गया, लेकिन यह बहुत अच्छी तरह से काम नहीं करता है - यहां मेरे पास अभी तक क्या है:

f=

([x,...s])=>x+s.map(y=>`<><>`[r=(d=y[c=`charCodeAt`]()-x[c](x=y))/13+2|0].repeat([d+26,-d,d,26-d][r])+`*`).join``

i.addEventListener("input",()=>o.innerText=i.value&&f(i.value))
console.log(f("adbc"))
console.log(f("aza"))
console.log(f("abcdef"))
console.log(f("zyaf"))
console.log(f("zzzzzz"))
console.log(f("z"))
console.log(f("zm"))
console.log(f("zl"))
console.log(f("alphabet"))
console.log(f("banana"))
console.log(f("abcdefghijklmnopqrstuvwxyz"))
console.log(f("abcdefz"))

<input id=i>
<pre id=o>

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

सहेजे गए 12 बाइट्स एक सुझाव के लिए धन्यवाद ल्यूक से स्ट्रिंग को नष्ट करने पर।
जोड़ा गया 1 बाइट चुनौती का एक गलत निर्धारण है, जो मुझे लगा कि एक अंतर्निहित अंतिम प्रिंट चरित्र के लिए अनुमति है।
ल्यूक द्वारा एक व्यापक पुनर्लेखन के लिए धन्यवाद एक और 18 बाइट्स बचाए।
2 बाइट्स जोड़े गए क्योंकि ऐसा लगता है कि संख्याएं मान्य प्रिंट वर्ण नहीं हैं।

मूल, 131 बाइट्स

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

f=

([x,...s])=>x+s.map(y=>(t=(d=y[c=`charCodeAt`]()-x[c](x=y))<0?-d:d,`<>`[+((r=t<13)&&d>0)||+(!r&&d<0)].repeat(r?t:26-t)+`*`)).join``

i.addEventListener("input",()=>o.innerText=i.value&&f(i.value))
console.log(f("adbc"))
console.log(f("aza"))
console.log(f("abcdef"))
console.log(f("zyaf"))
console.log(f("zzzzzz"))
console.log(f("z"))
console.log(f("zm"))
console.log(f("zl"))
console.log(f("alphabet"))
console.log(f("banana"))
console.log(f("abcdefghijklmnopqrstuvwxyz"))
console.log(f("abcdefz"))

<input id=i>
<pre id=o>

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

— झबरा
स्रोत

1

([x,...s])=>x+s.map(...)12 बाइट्स बचाता है। ध्यान दें कि आपको प्रिंट चरित्र को अंत तक जोड़ना चाहिए। मैं एक नंबर का उपयोग करने का सुझाव देता हूं, जिसके `1`+1बदले केवल 2 बाइट का खर्च आएगा `*`।

— ल्यूक

धन्यवाद, ल्यूक; मैं भूल गया था कि मैं इस तरह से एक स्ट्रिंग इनपुट को नष्ट कर सकता हूं। मुझे कल रात की चुनौती को गलत समझना चाहिए था; मैंने कसम खाई थी कि आखिरी प्रिंट चरित्र निहित था । दुर्भाग्य से, बस joinएक पत्र आदानों के लिए एक अवैध उत्पादन में परिणाम होता है के बाद पर यह से निपटने । हालांकि, प्रिंट चरित्र को mapविधि के भीतर ले जाने पर केवल 1 बाइट का खर्च आता है।

— झबरा

1

([x,...s])=>x+s.map(y=>'<><>'[r=(d=y[c='charCodeAt']()-x[c](x=y))/13+2|0].repeat([d+26,-d,d,26-d][r])+0).join``111 बाइट्स के लिए

— ल्यूक

धन्यवाद, फिर से, @Luke। इससे पहले कि मैं इसे संपादित करूं, क्या आप अपने स्वयं के उत्तर के रूप में उपरोक्त पोस्ट करना पसंद करेंगे? मुझे लगता है कि यह मेरे लिए पर्याप्त रूप से भिन्न है (लगभग एक हाइब्रिड इसका और अरनौल्ड का) इसके लिए ठीक है।

— झबरा

नहीं, आप इसे संपादित कर सकते हैं। मैंने एक reduceसमाधान के लिए गोल्फिंग की कोशिश की , लेकिन वह 115 बाइट निकला।

— ल्यूक

2

सी ++, ~~210~~ 190 बाइट्स

मेरी पहली गोल्फ में कोशिश करो!

#include<iostream>
int g(char*a){char k,j,d;std::cout<<*a;a++;for(;*a;a++){for(j=*(a-1),d=j-*a,k=d>0?d>13?62:60:d<-13?60:62;j!=*a;j+=k-61,j=j<97?122:j>122?97:j)std::cout<<k;std::cout<<'*';}}

k स्टोर करता है जो <,> या * प्रिंट करने के लिए है। पहले यह केवल सरणी के पहले तत्व को प्रिंट करता है फिर सरणी के पहले से अंतिम तत्व के लिए एक लूप चलाता है। j पिछले तत्व को संग्रहीत करता है और फिर तुलना करके अगर j को * by <या> क्रमशः k से <,> के पास सेट करें और फिर k को प्रिंट करें तब इस लूप को तब तक चलाएं जब तक कि j, p के बराबर न हो जाए। फिर दूसरे लूप प्रिंट के हर समाप्ति के बाद *।

— 0x81915
स्रोत

2

साइट पर आपका स्वागत है! अगर मुझे याद है कि सही ढंग *p!=0से बदला जा सकता है *p। मुझे पूरा यकीन है कि अंतरिक्ष char *aभी अनावश्यक है। आपको इसे पूर्ण उत्तर देने के लिए ( #include <iostream>और using namespace std;मुझे लगता है कि यह सिर्फ जोड़ने के लिए सस्ता हो सकता है std::) की आवश्यकता होगी।

— गेहूं जादूगर

2

साइट पर आपका स्वागत है! मुझे लगता है कि आपको शामिल करने की आवश्यकता है std::या using namespace std;आपको #include <iostream>अपनी बाइट गिनती में भी आवश्यकता होगी।

— DJMcMayhem

+1, लेकिन दो उपरोक्त बातों को ठीक करें, PPCG में आपका स्वागत है;)। मौका मिलने पर TIO Nexus ( tio.run/nexus ) के आसपास की कुछ भाषाओं को चेकआउट करें ! शायद खुद को डेनिस से मिलवाओ, वह एक प्रमुख दोस्त है जो इधर-उधर तैर रहा है।

— मैजिक ऑक्टोपस Urn

सुझावों के लिए सभी को धन्यवाद और गलतियों को इंगित करने के लिए। मैं शीघ्र ही कोड को अपडेट कर दूंगा।

— 0x81915

1

05AB1E , 17 बाइट्स

¬sÇ¥v„<>y0›èyÄ×ðJ

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

व्याख्या

उपयोग >, <और <space>निरूपित करने के लिए वेतन वृद्धि , घटती , प्रस्तुत

¬                  # get the first letter of the input string
 sÇ¥               # push a list of delta's of the character codes in the input string
    v              # for each delta
     „<>           # push the string "<>"
        y0›        # check if the delta is positive
           è       # use this to index into the string
            yÄ×    # repeat it abs(delta) times
               ðJ  # join to string with a space

— Emigna
स्रोत

और इसे 3 घंटे 3 से खो दिया।

— मैजिक ऑक्टोपस Urn

1

हास्केल , 167 168 126 बाइट्स

f=fromEnum
r=replicate
a?b=mod(f a-f b-13)26-13
c#x=r(c?x)'<'++r(-c?x)'>'
s(c,s)x=(x,s++c#x++"*")
e(x:y)=x:snd(foldl s(x,[])y)

अब xnor के अंकगणित समाधान का उपयोग कर। e strजहां str :: Stringएन्कोड किया जाना है, वहां कॉल करें ।

— जूलियन वुल्फ
स्रोत

1

हास्केल , 109 बाइट्स

a#b=mod(a-b-13)26-13
r=replicate
h(a:b:s)=r(a#b)'>'++r(-a#b)'<'++'*':h(b:s)
h e=""
f(a:r)=a:h(fromEnum<$>a:r)

इसे ऑनलाइन आज़माएं! Xnor के दृष्टिकोण का उपयोग करता है । के साथ बुलाओ f "somestring"।

— Laikoni
स्रोत

वृद्धिशील सिफर

सिफर स्पष्टीकरण

उदाहरण

नियम

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

कैसे?

8086 मशीन कोड, 70 68 67 बाइट्स

पायथन 3 , 87 बाइट्स

पायथन 3 , 110 93 बाइट्स

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

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

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

PHP, 127 बाइट्स

PHP, 137 बाइट्स

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

हास्केल (लैम्बडाबोट), 161 153 बाइट्स

एक्सेल VBA 130 बाइट्स

जावा 7-, 232 बाइट्स

सी, 170 बाइट्स

जावास्क्रिप्ट (ईएस 6), 140 128 129 111 113 बाइट्स

मूल, 131 बाइट्स

05AB1E , 17 बाइट्स

हास्केल , 167 168 126 बाइट्स

हास्केल , 109 बाइट्स