Diese Aufgabe ist recht einfach und verwendet drei unterschiedliche "Operator" -Zeichen. Ihre Aufgabe ist es , eine einfache Folge von Buchstaben angegeben, führen Sie die folgende Aufgabe , es zu codieren , mit <, >, *. Sie können entweder Groß- oder Kleinbuchstaben verwenden. Sie müssen nicht beide Zeichen verarbeiten.

Erklärung der Chiffre

Die Verschlüsselung ist einfach: Sie verwenden Inkrementierungs- und Dekrementierungsoperationen, um vom Buchstaben 1 zum Endbuchstaben zu gelangen, *wobei Sie die Funktion "Senden" haben. Der Operator für "Inkrementieren" ist >und "Dekrementieren" ist <.

Ein Beispiel mit dem Wort adbc:

• Beginnen Sie mit dem ersten Buchstaben des Wortes und geben Sie diesen Buchstaben aus. a
• Verwenden Sie >als nächstes und <(wie brainfuck), um durch den aktuellen Buchstaben zum nächsten zu navigieren. a>würde dazu führen a, dass der Buchstabe um 1 erhöht wird b. a<Dies würde dazu führen, zdass Sie den Buchstaben absenken (er wird umbrochen, Sie müssen immer die Richtung wählen, die zu der MINDESTEN Anzahl von Operationen führt).
• Nach der Ausgabe der richtigen minimierten Kombination von <und >Ausgabe von a, *um anzuzeigen, dass wir den nächsten Buchstaben erreicht haben.

Die zu codierenden Schritte adbcwären:

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

Beispiele

Die zu codierenden Schritte azawären:

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

Mehr Beispiele:

"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>*>*>*>*>*<<<<<<*"

Regeln

• Wir codieren und nicht decodieren, also bring das nicht durcheinander.
• Sie können davon ausgehen, dass die Nachricht Buchstaben [A-Z]oder [a-z]Ihre Wahl enthält.
• Sie können ein beliebiges nicht buchstabiertes / numerisches / reserviertes Zeichen verwenden, um *(EG $) zu kennzeichnen .
• Sie müssen das Ende haben *, es ist nicht implizit bei Wiederholungen.
• Sie dürfen keine leeren Zeichenketten annehmen, aber ein einzelnes Zeichen ist möglich.
• Wenn der Abstand zum nächsten Buchstaben gleich groß ist, können Sie eine Richtung wählen.
• Dies ist Code-Golf , die niedrigste Anzahl an Bytes gewinnt.

Bitte erläutern Sie Ihre Antwort, es hilft anderen, auf diese Weise zu lernen.

Gelee , 17 Bytes

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

Verwendet ein Leerzeichen anstelle von *(ein Leerzeichen ⁶oder eine neue Zeile ⁷speichert ein Byte mehr als ”*).

Funktioniert entweder nur mit Großbuchstaben oder nur mit Kleinbuchstaben.

Probieren Sie es online! oder sehen Sie sich eine Testsuite an (in der diese Leerzeichen*zur Erleichterung des Lesensnachträglich durch ersetzt werden).

Wie?

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>>> << > "

8086 Maschinencode, 70 68 67 Bytes

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

Wie es funktioniert:

            |   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

Python 3 , 87 Bytes

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

Probieren Sie es online!

Funktioniert entweder mit Klein- oder Großbuchstaben.

Das Programm erstellt die Ausgabezeichenfolge, rwährend es die Zeichen in der Eingabezeichenfolge durchläuft. Es speichert das vorherige Zeichen als pund berechnet die Inkrementierungsoperation, um vom pneuen Zeichen zum neuen Zeichen zu gelangen c.

Das Intervall zwischen den Zeichen ist ord(c)-ord(p), und es (ord(c)-ord(p)-13)%26-13dauert modulo 26 bis das Intervall [-13..12]. Ein negatives Ergebnis bedeutet, dass das Zurücktreten kürzer ist, und ein positives Ergebnis bedeutet, dass das Zurücktreten kürzer ist. Dies muss in eine Zeichenfolge von >oder <abhängig von dem Vorzeichen konvertiert werden . Anstatt abseine Bedingung oder eine Bedingung zu verwenden, nutzen wir die String-Multiplikation von Python s*n, um den leeren String zu erhalten, wenn er nnegativ ist. Im Ausdruck '<'*-d+'>'*dträgt der falsch signierte Teil nicht bei.

Der Anfangszustand wird durch Aufteilen der Eingabe in das erste Zeichen und den Rest durch Entpacken von Python 3 behandelt r,*s=input(). Das Anfangszeichen wird verwendet, um mit dem Erstellen des Strings zu beginnen, sowie das anfängliche "vorherige" Zeichen.

Vielen Dank an ovs für den Vorschlag, zu Python 3 zu wechseln, um dieses Entpacken durchzuführen.

Python 3 , 110 93 Bytes

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)

Probieren Sie es online!

JavaScript (ES6), 118 109 107 Byte

Bei der Eingabe wird die Groß- und Kleinschreibung nicht berücksichtigt.

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)

Wie es funktioniert

Im Gegensatz zu Python gibt der JS-Modulo-Operator eine Zahl mit demselben Vorzeichen wie die Dividende und nicht wie der Divisor zurück. Außerdem gibt die JS- repeat()Methode einen Fehler aus, wenn eine negative Zahl angegeben wird, anstatt eine leere Zeichenfolge zurückzugeben (und dies ist *ohnehin erheblich länger als eine einfache Zeichenfolge ).

Dies sind eher ungünstige Verhaltensweisen für diese Herausforderung. Wir sollten also besser herausfinden, in welchem ​​Fall wir uns genau befinden, als uns auf mathematische Tricks zu verlassen. (Das heißt nicht, dass es solche Tricks nicht gibt, sondern dass ich sie nicht gefunden habe.)

Nachfolgend finden Sie eine Tabelle, in der die 4 möglichen Fälle beschrieben werden. Dabei dhandelt es sich um den vorzeichenbehafteten Abstand zwischen dem aktuellen und dem vorherigen Zeichen:

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

Testfälle

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"));

PHP, 127 Bytes

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;

Testfälle

PHP, 137 Bytes

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;

Testfälle

JavaScript (ES6), 111 103 Byte

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

Ursprünglich hat die Version 111 Bytes gedauert, bevor ich @ Arnauld's Trick des Einstellens nwährend des Rechnens angepasst habe. pIch denke, es gibt wahrscheinlich einen anderen Trick, sder verwendet wird, naber es wird spät, so dass ich mich nicht darum kümmere:

Haskell (Lambdabot), 161 153 Bytes

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])++"*"

Probieren Sie es online!

Erläuterung:

-- 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
          )

EXCEL VBA 130 Bytes

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

Führen Sie es aus dem Excel VBA-Direktfenster aus.

Erläuterung:

Einfache for-Schleife, die mit der String-Funktion die Anzahl ">" oder "<" n wiederholt, wobei n die ASCII-Differenz zwischen der i- und der i + 1-Zeichenfolge ist.

Java 7-, 232 Bytes

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

So ziemlich die triviale Lösung. Ungolfed und kommentiert:

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

C 170 Bytes

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

Ausführliches Live

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
}

JavaScript (ES6), 140 128 129 111 113 Byte

Ich bin einen anderen Weg gegangen als die anderen JS-Lösungen, aber es hat nicht allzu gut geklappt - hier ist, was ich bisher habe:

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>

• Dank eines Vorschlags von Luke zur Destrukturierung der Zeichenfolge wurden 12 Byte eingespart.
• 1 Byte hinzugefügt, um ein falsches Lesen der Herausforderung zu korrigieren, was meiner Meinung nach ein implizites endgültiges Druckzeichen ermöglichte.
• Weitere 18 Bytes wurden dank eines umfassenden Umschreibens von Luke eingespart.
• 2 Bytes hinzugefügt, da Zahlen keine gültigen Druckzeichen zu sein scheinen.

Original, 131 Bytes

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>

C ++, 210 bis 190 Bytes

Mein erster Versuch beim Golfen!

#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 speichert, welches von <,> oder * gedruckt werden soll. Zuerst wird einfach das erste Element des Arrays gedruckt und dann eine Schleife für ein vom ersten bis zum letzten Element des Arrays ausgeführt. j speichert das vorherige Element und vergleicht dann, ob j näher an * a liegt, indem <oder> k auf <,> gesetzt und dann k gedruckt wird, und führt dann diese Schleife aus, bis j gleich p wird. Dann nach jedem Ende der zweiten Schleife drucken *.

05AB1E , 17 Bytes

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

Probieren Sie es online!

Erläuterung

Anwendungen >, <und <space>zu bezeichnen Erhöhung , Verminderung , einreichen

¬                  # 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

Haskell , 167 168 126 Bytes

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)

Verwenden Sie jetzt die arithmetische Lösung von xnor. Rufen Sie mit auf, e strwo str :: Stringdie zu codierende Zeichenfolge ist.

Haskell , 109 Bytes

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)

Probieren Sie es online! Verwendet den Ansatz von xnor . Mit anrufen f "somestring".