Die Entschlüsselungsfunktion
Sie müssen ein Programm schreiben, das eine verschlüsselte Zeichenfolge verwendet, diese nach bestimmten Regeln entschlüsselt und dann ausdrucken. Die Entschlüsselung erfolgt durch Ausführen von zwei Vorgängen.
Beispiel für ein Eingabeargument 1 (die verschlüsselte Zeichenfolge)
HGJILKBADCFE
Operation 1:
Tauschen Sie die erste Hälfte der Saite gegen die zweite Hälfte aus, damit Sie Folgendes erhalten:
BADCFEHGJILK
Operation 2:
Tauschen Sie alle zwei Zeichen miteinander aus, z. B. tauschen Sie Zeichen 1 mit 2, 3 mit 4 usw. aus, wodurch Sie die entschlüsselte Zeichenfolge erhalten sollten:
ABCDEFGHIJKL
Richtlinien:
Das Eingabeargument 1 enthält nur Großbuchstaben
Die Länge des Eingabearguments 1 liegt zwischen 2 und 100 Zeichen
Die Länge des Eingabearguments 1 ist immer eine gerade Zahl
Die Eingabe erfolgt vorzugsweise über die Befehlszeile (wie unten).
Ein weiterer Testfall
MPORQTSVUXWZYBADCFEHGJILKNist die Eingabe, Ausgabe istABCDEFGHIJKLMNOPQRSTUVWXYZ
Mein Versuch
import sys
_,a=sys.argv
b=len(a)//2
s=a[b:]+a[:b]
print(''.join(x+y for x,y in zip(s[1::2],s[::2])))
Antworten
J , 15 Bytes
[:,_2|.\-:@#|.]
Probieren Sie es online aus!
Einfache Umsetzung der Formel.
Etwas interessanter (nicht hilfreich für J-Golf, aber vielleicht für eine andere Sprache) ist, dass der Algorithmus mit einer Scansumme gelöst werden kann:
- Nehmen Sie zuerst ein
1gefolgt von-1 3, mit-1 3bis zur Länge der Liste wiederholt. - Scannen Sie die Summe dieser Liste.
- Drehen Sie die Zahlen um die halbe Listenlänge.
- Sortieren Sie das Original nach diesen Zahlen.
Eine Demo finden Sie im TIO in J.
Ruby -p , 48 47 Bytes
$_=$_[l= ~/$//2,l]+$_[0,l];gsub /(.)(.)/,'\2\1'
Probieren Sie es online aus!
Operation 1 wird durch Aufteilen $_(der vordefinierten globalen Variablen, die die Eingabe enthält) in zwei Teilzeichenfolgen gleicher Länge behandelt. ~/$/gibt die Länge der Eingabe an. Schließen Sie gsub /(.)(.)/,'\2\1'dann Vorgang 2 ab, indem Sie jedes Zeichenpaar austauschen. (Mit der -pFlagge, gsubohne dass ein Empfänger implizit einwirkt $_.)
05AB1E , 13 12 Bytes
D2äRJ2ι`s.ιJ
Probieren Sie es online aus!
-1 Dank eines Golftipps von @Kevin sah ich eine andere Antwort
Erklärt
D2äRJ2ι`s.ιJ
- Dupliziere die Eingabe (
D) - Teile es in 2 Stücke (
2ä) - Kehren Sie die Liste um und verbinden Sie sie zu einer einzelnen Zeichenfolge (
RJ) - Deaktivieren Sie diese Zeichenfolge bei jedem zweiten Zeichen (
2ι) - Schieben Sie alle Elemente aus der nicht verschachtelten Zeichenfolge auf den Stapel (`` `)
- Verschachteln Sie diese Elemente (
.ι) - Und schließen Sie sich der resultierenden Liste an (
J)
APL + WIN, 24 22 Bytes
-2 Bytes dank Jo King
Eingabeaufforderungen zur Eingabe der Zeichenfolge:
,⌽n⍴⊖(⌽n←⌽2,.5×⍴s)⍴s←⎕
Probieren Sie es online aus! Mit freundlicher Genehmigung von Dyalog Classic
R , 78 80 79 Bytes
Bearbeiten: +2 Bytes dank Dingus für das Erkennen von Fehlern und -1 Bytes dank pajonk
n=nchar(s<-scan(,''));o=1:n;cat(substring(s,p<-(o+n/2-2+2*o%%2)%%n+1,p),sep='')
Probieren Sie es online aus!
Eingabe über die R-Konsole (die als 'Befehlszeile' für den R-Arbeitsbereich angesehen werden kann).
R kann auch von einer (Nicht-R-) Shell über das RscriptHelfer-Frontend aufgerufen werden , wodurch Befehlszeilenargumente direkt auf den Aufruf folgen können. In diesem Fall könnte ein modifiziertes Programm 87 Byte lang sein und mit aufgerufen werden Rscript decrypt.r HGJILKBADCFE.
Berechnet die Positionen dekodierter Buchstaben und gibt dann eine neu angeordnete Zeichenfolge aus.
Kommentiert:
n=nchar( # n = number of characters in...
s<-scan(,'')); # s = the input.
o=1:n; # o = sequence from 1 to n
p= # p = positions of decoded characters:
(o+n/2-1 # - reverse the first & second halves of o
# by adding n/2-1
# (will be fixed with final modulo below)
+2*o%%2-1) # - then add 2 at every odd position
# and subtract 1 from all, so in effect
# adding to odds & subtracting from evens
%%n # - all modulo n
+1 # - add 1 to get 1-based indices
cat( # output:
substring(s,p,p),sep='') # characters of s from positions p to p
Gelee , 7 Bytes
ŒHṚFs2U
Probieren Sie es online aus!
Entsprechend 7 Bytes , ṙLH$s2U.
Erläuterung
ŒHṚFs2U Main Link
ŒH Split into two halves of similar length
Ṛ Reverse the order (swap the two halves)
F Flatten back into a single string
s2 Slice into chunks of length 2
U Reverse each chunk
Output is implicitly as one string
Der andere ṙotiert es durch $( Half der Saitenlänge L) und macht dann dasselbe für den zweiten Teil der Herausforderung.
Python 3 , 75 Bytes
Genau wie gefragt: Eingabe über die Befehlszeile, Ausgabe an STDOUT.
import sys
_,s=sys.argv
i=1
while s[i:]:print(end=s[i-len(s)//2]);i+=3|i%-2
Probieren Sie es online aus!
Python 2 , 52 Bytes
Wenn wir eine Funktion verwenden können:
f=lambda s,i=1:s[i:]and s[i-len(s)/2]+f(s,i+3-i%2*4)
Probieren Sie es online aus!
Die Idee von all diesen ist, dass der Index des \$i\$'th Ausgabezeichen in einer Zeichenfolge der Länge \$n\$ ist:
$$ i - \frac{n}{2} + (-1)^i $$
Vorbehaltlich der üblichen Python-Indizierungssemantik. Wenn wir dies iterativ umschreiben, wird das \$i\$Das Ausgabezeichen ist:
$$ a_i - \frac{n}{2} \text{ where } a_0 = 1 \text{ and } a_i = a_{i-1} + 3 - 4(i\%2) $$
Kürzer mit gewisser Priorität ist:
$$ a_i - \frac{n}{2} \text{ where } a_0 = 1 \text{ and } a_i = a_{i-1} + 3|(i\%-2) $$
Python 2 , 50 Bytes
f=lambda s,i=0:s[i:]and s[(i^1)-len(s)/2]+f(s,i+1)
Probieren Sie es online aus!
In Anlehnung an Sisyphus ist das i'th-Zeichen der Ausgabe das Zeichen am Index (i^1)-len(s)/2der Eingabe. Hier i^1ist XOR mit 1, die das letzte Bit Flips und so Swaps gerade / ungerade Paare 0<->1, 2<->3, 4<->5, ...
Hier ist eine nicht rekursive Alternative für dieselbe Länge, obwohl sie eine Liste von Zeichen ausgibt, von denen ich nicht sicher bin, ob sie zulässig sind.
lambda s:[s[(i^1)-len(s)/2]for i in range(len(s))]
Probieren Sie es online aus!
C (gcc) , 73 72 70 Bytes
2 Bytes dank Dominic van Essen gespart !!!
i;l;f(char*s){for(i=1;(l=strlen(s))/i;)putchar(s[(i+l/2-++i%2*2)%l]);}
Probieren Sie es online aus!
Gibt einen String ein und gibt die Entschlüsselung aus.
Erläuterung
Ordnet den Index zu (beginnend bei \$0\$bis zum Ende) der Eingabezeichenfolge \$s\$von Länge \$l\$, an die richtige Stelle, indem Sie es über \ verschieben$\frac{l}{2}+1\$Orte und dann zurück \$2\$für ungerade Indizes. Verwenden dieses \$\mod{l}\$gibt den korrekten Index von \ an$s\$ für das nächste Ausgabezeichen.
JavaScript (Node.js) ,
71
65 Bytes
s=>(s.slice(l=s.length/2)+s.slice(0,l)).replace(/(.)(.)/g,'$2$1')
Probieren Sie es online aus!
6 Bytes dank @Shaggy gespeichert.
Ursprüngliche 71-Byte-Lösung:
s=>(l=>s.slice(l)+s.slice(0,l))(s.length/2).replace(/(\w)(\w)/g,'$2$1')
Ziemlich einfaches Zeug hier - ich habe eine innere Funktion verwendet, weil ich die sliceAufrufe sowieso umgeben musste - das spart 4 Bytes.
Brachylog , 8 Bytes
ḍ↔cġ₂↔ᵐc
Probieren Sie es online aus!
Wie es funktioniert
ḍ↔cġ₂↔ᵐc
ḍ split in two halves
↔ reverse
c join
ġ₂ group with length two
↔ᵐ reverse each
c join
Python 3 , 91 Bytes
a=input();x=len(a)//2;b=a[x:]+a[:x];c=''
for i in range(0,len(b),2):c+=b[i+1]+b[i]
print(c)
Probieren Sie es online aus!
Pip , 21 Bytes
RV_M(JRV(a<>#a/2)<>2)
Probieren Sie es online aus!
Erläuterung
RV_M(JRV(a<>#a/2)<>2)
(a<>#a/2) split input into parts of size length/2
JRV reverse the list, and join it to string
<>2 split the joined string into parts of size 2
RV_M reverse each of those parts
implicit output
C (gcc) , 78 76 78 74 Bytes
Danke an Ceiletcat für die -4!
Bearbeiten: Zurückgesetzt, um Addition anstelle von ODER zu verwenden, um Probleme mit der Priorität des Operators zu vermeiden.
Anstatt die Zeichenfolge zu teilen, beginnt die Funktion in der Mitte der Zeichenfolge und umschließt die gesamte Zeichenfolge, die verarbeitet wurde. Um jedes andere Zeichen umzudrehen, kehrt der Index die 1s-Position des Zählers um.
f(s,i,j)char*s;{for(i=strlen(s),j=0;write(1,s+(i/2+j++/2*2+j%2)%i,j<i););}
Probieren Sie es online aus!
Wenn das Programm unbedingt von der Kommandozeile nehmen muss: 82 Bytes
main(i,s,j)char**s;{for(i=strlen(*++s),j=0;write(1,*s+(i/2+j++/2*2+j%2)%i,j<i););}
Probieren Sie es online aus!
Stax , 10 Bytes
ü♠yαæ♠╟«ºñ
Führen Sie es aus und debuggen Sie es
Was für ein wunderbarer Online-Dolmetscher.
Der Link führt zur entpackten Version des Codes.
Erläuterung
;%h/r$2/Frp ; copy input % get it's length h halve it / split input into parts of that size r reverse $ join to string
2/ split into parts of size 2
F for each element in the resulting array:
rp reverse, and print without newline.
K (ngn / k) , 17 Bytes
,/|'0N 2#,/|2 0N#
Probieren Sie es online aus!
Faktor 89 Bytes
: d ( s -- s ) halves swap [ >array ] bi@ append 2 group [ reverse ] map concat >string ;
Probieren Sie es online aus!
R , 64 63 Bytes
m=matrix;intToUtf8(m(m(utf8ToInt(scan(,"")),,2)[,2:1],2)[2:1,])
Probieren Sie es online aus!
Er verfolgte einen anderen Ansatz als Dominic van Essen , der ein Byte nach unten spielte. Verwendet die Matrixumformung / -indizierung, um die Umkehrung durchzuführen.
Ungolfed:
s <- utf8ToInt(scan(,"")) # read input and convert to a list of byte values
m <- matrix(s,,2) # convert to a Nx2 matrix, filling down by columns
m <- m[,2:1] # reverse the columns of the matrix (flip the halves)
m <- matrix(m,2) # convert to an Nx2 matrix, filling down by the columns
m <- m[2:1,] # reverse the rows (swap adjacent characters)
intToUtf8(m) # convert back to string
Bash + Sed, 57 Bytes
Übernimmt die Eingabe als Befehlszeilenargument.
<<<"${1:${#1}/2}${1:0:${#1}/2}" sed 's/\(.\)\(.\)/\2\1/g'
Probieren Sie es online aus!
Burlesque , 17 Bytes
iRsa2./!!2co)<-++
Probieren Sie es online aus!
Beschreibung:
iR # Generate all rotations of the input string
sa # Duplicate and get length (which equals string length)
2./ # Divide by two
!! # And grab the string that's been rotated that many times
2co # Split the rotated string into chunks of two
<- # Reverse each chunk
++ # Join together and implicitly output
Japt -P , 9 Bytes
éUÊz)ò mw
Versuch es
éUÊz)ò mw :Implicit input of string U
é :Rotate right by
UÊ : Length of U
z : Floor divided by 2
) :End rotate
ò :Partitions of length 2
m :Map
w : Reverse
:Implicitly join and output
Holzkohle , 13 Bytes
⭆⪪⪫⮌⪪θ⊘Ｌθω²⮌ι
Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:
θ Input string
Ｌ Length
⊘ Halved
⪪θ Split input string into substrings of this length
⮌ Reverse
⪫ ω Join together
⪪ ² Split into substrings of length 2
⭆ Map over substrings and join
ι Current substring
⮌ Reversed
Implicitly print
Retina 0,8,2 , 36 Bytes
((.)+?)((?<-2>.)+)$ $3$1 (.)(.) $2$1
Probieren Sie es online aus! Erläuterung: In der ersten Phase wird eine .NET-Ausgleichsgruppe verwendet, um so wenig Zeichen wie möglich $1zuzuordnen und gleichzeitig die gleiche Anzahl von Zeichen zuzuordnen $3. $#2Inkremente für jedes übereinstimmende Zeichen $1und Dekremente für jedes übereinstimmende Zeichen $3, können jedoch nicht unter Null dekrementieren. $1Daher muss die erste Hälfte der Zeichenfolge verwendet werden, damit das Ende der Zeichenfolge erreicht werden kann. In der zweiten Stufe werden dann Paare benachbarter Zeichen umgedreht. (Auch ASCII Kunst bewbs.)
MathGolf , 10 Bytes
h½/xy2/mx~
Probieren Sie es online aus.
Erläuterung:
h # Get the length of the (implicit) input-string (without popping)
# i.e. "HGJILKBADCFE" → "HGJILKBADCFE" and 12
½ # Halve this length
# → "HGJILKBADCFE" and 6
/ # Split the string into parts of that size
# → ["HGJILK","BADCFE"]
x # Reverse this pair
# → ["BADCFE","HGJILK"]
y # Join it back together to a string
# → "BADCFEHGJILK"
2/ # Split it into parts of size 2
# → ["BA","DC","FE","HG","JI","LK"]
m # Map over each pair:
x # Reverse the pair
# → ["AB","CD","EF","GH","IJ","KL"]
~ # Pop and push all strings separated to the stack
# → "AB", "CD", "EF", "GH", "IJ", and "KL"
# (after which the entire stack joined together is output implicitly)
# → "ABCDEFGHIJKL"
Rot , 89 Bytes
func[s][move/part s tail s(length? s)/ 2
rejoin collect[foreach[b a]s[keep rejoin[a b]]]]
Probieren Sie es online aus!
Lua , 67 Bytes
a=...b=#a//2print(((a:sub(b+1)..a:sub(1,b)):gsub('(.)(.)','%2%1')))
Probieren Sie es online aus!
Zuerst wird die Zeichenfolge mithilfe von subFunktionen in zwei Teile geschnitten und dann in umgekehrter Reihenfolge wieder verkettet. Wird gsubdann verwendet, um Zeichenpaare auszutauschen.
Wolfram Language (Mathematica) , 64 51 Bytes
#[[#+UnitStep@#&@Array[#+(-1)^#&,L=Tr[1^#],-L/2]]]&
Probieren Sie es online aus!
Port der Python-Lösung von Sisyphus
CJam , 13 Bytes
q2/::\_,2//:\
Probieren Sie es online aus!
Perl 5 -pF , 40 Bytes
for$p("."x(@F/2),"."){s/($p)($p)/$2$1/g}
Probieren Sie es online aus!
Poetisch , 472 Bytes
DECODING THINGS:A BRIEFING
o,o,hello!i am agent Q
nah,Q`s chosen by an infamous phoney
a misprint!oh,sorry!am i sorry
i am agent J.W,tech/A.I hacker
i see a piece o code,i am trying at a means on how i decode it
what i am doing:i am laying all A-Z clearly along a pathway
midway,put in zeros(O,O)cause J.W needs it to split em
i shift em in tandem,i get B,A
lastly,if it leaves you a letter,it is moved
o,then i am doing A-Z again,it is taken to a shift
ah ha!spying is EZ
Probieren Sie es online aus!