Chaînes entrelacées

34

Votre défi consiste à écrire un programme ou une fonction qui, lorsque deux chaînes de longueur égale sont définies, permute tous les autres caractères et génère / renvoie les chaînes résultantes dans l'un ou l'autre ordre.

Exemples

"Hello," "world!" --> "Hollo!" "werld,"
"code" "golf" --> "codf" "gole"
"happy" "angry" --> "hnpry" "aagpy"
"qwerty" "dvorak" --> "qvertk" "dworay"
"1, 2, 3" "a, b, c" --> "1, b, 3" "a, 2, c"
"3.141592653589" "2.718281828459" --> "3.111291623489" "2.748582858559"
"DJMcMayhem" "trichoplax" --> "DrMcMoylex" "tJichapham"
"Doorknob" "Downgoat" --> "Doonkoot" "Dowrgnab"
"Halloween" "Challenge" --> "Hhlloeegn" "Caallwnee"

Règles

  • Les chaînes ne contiendront que des caractères ASCII (32-126).
  • Les chaînes auront toujours la même longueur et ne seront jamais vides.
  • Vous pouvez accepter une entrée dans n’importe quel format approprié: paramètres séparés, éléments d’un tableau, séparés par un ou plusieurs sauts de ligne, voire concaténés. La seule restriction est qu'une chaîne doit précéder complètement l'autre (par exemple, a1\nb2\nc3for "abc", "123"est invalide).
  • La sortie peut être dans l’un ou l’autre ordre (c’est-à-dire que vous pouvez commencer à permuter à partir du premier ou du deuxième caractère) et dans tout format valide mentionné ci-dessus. (Tableau à 2 éléments, séparés par une ou plusieurs nouvelles lignes, concaténés, etc.)

Notation

C'est du , donc le code le plus court en octets pour chaque langue gagne.

ETHproductions
la source
11
+1 pour DrMcMoylex. : D
DJMcMayhem
3
"Dowrgnab" anagrammes en "Downgrab" (Fun ° Roll ͡ °)
Mama Fun Roll
Vous devez indiquer explicitement que la règle "dans l'un ou l'autre ordre" signifie que l'échange peut commencer à partir du premier ou du second caractère.
DLosc
@DrMcMoylex Prenons le code, exemple de golf . Si on échange à partir de deuxième caractère, on obtient: c o d f , g o l e . À partir du premier caractère: G o l e, c o d f.
DLosc

Réponses:

14

Haskell, 37 octets

l=(,):flip(,):l
(unzip.).zipWith3($)l

Zip les deux chaînes, en échangeant les caractères, puis les décompresse.

Une alternative récursive de 37 octets:

(a:b)?(c:d)=a:d?b
e?_=e
a%b=(a?b,b?a)
Xnor
la source
9

Python, 42 octets avec golf I / O

def f(a,b):a[1::2],b[1::2]=b[1::2],a[1::2]

Échange tous les autres caractères des deux listes. Prend en entrée deux listes de caractères et les édite en les modifiant .

l=list('cat')
m=list('dog')    
print l,m

def f(a,b):a[1::2],b[1::2]=b[1::2],a[1::2]

f(l,m)
print l,m

donne

['c', 'a', 't'] ['d', 'o', 'g']
['c', 'o', 't'] ['d', 'a', 'g']
Xnor
la source
1
C'est malin. Voyez-vous les formats d'entrée / sortie trop flexibles?
ETHproductions
@ETHproductions Pas sûr, c'est peut-être principalement spécifique à Python que les listes sont tellement manipulables que des chaînes.
xnor
8

Vim, 18 , 17 octets

qqyljvPkvPll@qq@q

Essayez-le en ligne!

Ceci utilise l'interpréteur V en raison de la compatibilité ascendante. L'entrée se présente sous ce format:

string1
string2

Explication:

 qq                 " Start recording in register 'q'
   yl               " Yank one letter
     j              " Move down a row
      vP            " Swap the yanked letter and the letter under the cursor
        k           " Move back up a row
         vP         " Swap the yanked letter and the letter under the cursor
           ll       " Move two letters to the right. This will throw an error once we're done
             @q     " Call macro 'q' recursively
               q    " Stop recording.
                @q  " Start the recursive loop
DJMcMayhem
la source
Couper deux lettres en utilisant xau lieu de ylpuis jus Pau lieu de seconde vP:lqqxjvPkPll@qq@q
Hauleth
@lukasz J'avais essayé cela au début, mais pour une raison quelconque, cela le lance trop souvent et échange les dernières lettres alors que ce ne devrait pas être le cas. J'y reviendrai un peu plus
DJMcMayhem
Fonctionne pour moi v.tryitonline.net/…
Hauleth
1
@ ŁukaszNiemier Ce lien a le même code que j'ai posté. Avez-vous appuyé sur le [save]bouton? De toute façon, ça ne marche pas pour moi . La vraie raison est que, lorsque vous êtes xle dernier caractère de la ligne, votre curseur se déplace vers la gauche, ce qui perturbe le placement de la permutation.
DJMcMayhem
6

Haskell, 41 octets

(a:b)#(c:d)=(a,c):d#b
_#_=[]
(unzip.).(#)

Retourne une paire avec les chaînes. Exemple d'utilisation: ( (unzip.).(#) ) "Hello," "world!"-> ("Hollo!","werld,").

Approche récursive simple: prenez le premier caractère de chaque chaîne sous forme de paire et ajoutez un appel récursif avec les chaînes restantes échangées. unzipfait une paire de listes de la liste des paires.

nimi
la source
6

05AB1E , 11 à 10 octets

øvyNFÀ}})ø

Essayez-le en ligne!

Explication

input = ["code", "golf"]utilisé à titre d'exemple.

ø             # zip strings into list of pairs
              # STACK: ['cg', 'oo', 'dl', 'ef']
 vy           # for each pair
   NFÀ        # rotate left index times
      }}      # end-if, end-loop
              # STACK: 'cg, 'oo', 'dl', 'fe'
        )ø    # wrap in list and zip
              # OUTPUT: ['codf', 'gole']
Emigna
la source
5

Perl, 48 octets

Bytecount comprend 47 octets de code et d' -pindicateur.

say<>=~s%.\K(.)%"s/.{$-[0]}\\K(.)/$1/;\$1"%geer

Courir avec -pet -Edrapeau. Attendez-vous à chaque chaîne sur une ligne différente:

perl -pE 'say<>=~s%.\K(.)%"s/.{$-[0]}\\K(.)/$1/;\$1"%geer' <<< "Hello
World"

Explications :

-p: capturer une entrée $_et l’imprimer à la fin. (pour obtenir et imprimer la première chaîne)
<>: obtenir une ligne de saisie. (pour obtenir la deuxième chaîne).
=~: Appliquer une expression rationnelle <>: s%%%geer, où , grâce à rla chaîne modifiée est retournée (puis imprimé grâce à say).
La regex:
.\K(.)trouve deux caractères, et remplacera le second par le résultat de l'évaluation de ce code "s/.{$-[0]}\\K(.)/$1/;\$1":
La première partie s/.{$-[0]}\\K(.)/$1/applique une regex à $_: .{$-[0]}saute les premiers caractères pour atteindre le même point que la regex externe (car $-[0]contient le index du premier groupe de capture, donc dans ce cas, l'index des caractères à substituer), puis nous capturons un caractère avec(.)et remplacez-le par le caractère de la regex externe ( $1). Et puis nous ajoutons $1donc le résultat de "s/.{$-[0]}\\K(.)/$1/;\$1"est le caractère que nous avons capturé dans la regex interne.
Vous avez peut-être remarqué que $1vous vous référez au caractère que nous voulons remplacer dans les deux chaînes (donc deux caractères différents), nous jouons donc avec le /eemodificateur de la regex qui évalue le côté droit de la regex deux fois: le premier ne remplacera que le caractère $1isn 'pas précédé par le \.

Dada
la source
5

Python, 55 octets

lambda a,b:[(-~len(a)/2*s)[::len(a)+1]for s in a+b,b+a]

Trancher!

58 octets:

def f(a,b):n=len(a);print[(s*n)[:n*n:n+1]for s in a+b,b+a]

64 octets:

f=lambda a,b,s='',t='':a and f(b[1:],a[1:],s+a[0],t+b[0])or[s,t]

Accumule de manière récursive les caractères des deux chaînes dans set t, et renvoie la paire à la fin. L'alternance est effectuée en commutant les chaînes d'entrée à chaque appel récursif. La sortie d'une chaîne séparée par des espaces avait la même longueur:

lambda a,b,s='',t=' ':a and f(b[1:],a[1:],s+a[0],t+b[0])or s+t

Cela évite de près une stratégie récursive différente consistant à prendre alternativement les caractères de chaque chaîne, chacune des deux chaînes possibles étant la première. (65 octets)

g=lambda a,b:a and a[0]+g(b[1:],a[1:])
lambda a,b:(g(a,b),g(b,a))
Xnor
la source
4

MATL , 11 10 9 8 octets

Merci à ETHproductions pour 1 octet de moins!

"@X@YS&h

L' entrée est un tableau 2D contenant les deux chaînes, telles que: ['Halloween'; 'Challenge']. Les chaînes de sortie sont dans l'ordre inverse.

Essayez-le en ligne!

Explication

        % Input 2D array implicitly
"       % For each column
  @     %   Push current column
  X@    %   Push iteration index, starting at 1
  YS    %   Circularly shift the column by that amount
  &h    %   Concatenate horizontally with (concatenated) previous columns
        % End implicitly
        % Display implicitly

Ancienne version: 9 octets

tZyP:1&YS

Explication

        % Take input implicitly
t       % Duplicate 
        % STACK: ['Halloween'; 'Challenge'], ['Halloween'; 'Challenge']
Zy      % Size
        % STACK: ['Halloween'; 'Challenge'], [2 9]
P       % Flip array
        % STACK: ['Halloween'; 'Challenge'], [9 2]
:       % Range. Uses first element of the array as input
        % STACK: ['Halloween'; 'Challenge'], [1 2 3 4 5 6 7 8 9]
1&YS    % Circularly shift each column by those amounts respectively
        % STACK: [Caallwnee';'Hhlloeegn']
        % Display implicitly
Luis Mendo
la source
@ETHproductions Oui! Merci!
Luis Mendo
4

Gelée , 5 octets

żṚż¥/

L'entrée est sous forme d'arguments séparés, la sortie est concaténée.

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça marche

żṚż¥/  Main link. Left argument: s (string). Right argument: t (string)

ż      Zipwith; yield the array of pairs of corresponding characters of s and t.
   ¥   Combine the two links to the left into a dyadic chain:
 Ṛ         Reverse the chain's left argument.
  ż        Zip the result with the chain's right argument.
    /  Reduce the return value of the initial ż by the quicklink Ṛż¥.
Dennis
la source
4

Gelée , 9 8 6 octets

Merci à Dennis d' avoir économisé 2 octets!

Zṙ"J$Z

Utilise le codage Jelly .

Essayez-le en ligne!

Adnan
la source
Vous pouvez utiliser ṙ"J$au lieu de Ėṙ@/€. De plus, il n'est pas nécessaire de séparer la chaîne, vous pouvez donc supprimer le fichier Y.
Dennis
@ Dennis Ahh, c'est chouette. Merci! :)
Adnan
3

V , 12 octets

lòyljvPkvPll

Essayez-le en ligne!

Rien d’intéressant, juste un portage direct de ma réponse vim pour pouvoir rivaliser avec (mais pas battre) 05AB1E.

DJMcMayhem
la source
3

Pyke, 9 octets

,Fo2%I_(,

Essayez-le ici!

          - o = 0
,         -   transpose(input)
 F     (  -  for i in ^:
  o2%     -    (o++ %2)
     I_   -   if ^: i = reverse(i)
        , - transpose(^)
Bleu
la source
3

JavaScript (ES6), 51 54

Éditez 3 octets enregistrés thx @Neil

Fonction avec tableau entrée / sortie

p=>p.map((w,i)=>w.replace(/./g,(c,j)=>p[i+j&1][j]))

J'aime celui-ci de plus, mais c'est 55 (2 chaînes en entrée, tableau en sortie)

(a,b)=>[...a].reduce(([p,q],c,i)=>[q+c,p+b[i]],['',''])

Tester

f=
p=>p.map((w,i)=>w.replace(/./g,(c,j)=>p[i+j&1][j]))

function go() {
  var a=A.value, b=B.value
  if (a.length == b.length)
    O.textContent = f([a,b]).join('\n')
  else
    O.textContent = '- different length -'
    
}

go()
<input id=A value='Hello,'><input id=B value='world!'>
<button onclick='go()'>go</button><pre id=O></pre>

edc65
la source
replacevous permet d' économiser 3 octets: p=>p.map((w,i)=>w.replace(/./g,(c,j)=>a[i+j&1][j])).
Neil
2

Pyth, 8 octets

C.e_FbkC

Essayez-le en ligne: démonstration

Transpose les mots, inverse les "index actuels" de chaque paire de lettres, transpose à nouveau.

Jakube
la source
2

JavaScript (ES6), 55 octets

f=([c,...s],[d,...t],o="",p="")=>c?f(t,s,o+c,p+d):[o,p]

Je voulais faire quelque chose d'intelligent avec l'utilisation de regexp pour remplacer les caractères de remplacement, mais cela a pris 67 57 octets:

a=>a.map((s,i)=>a[+!i].replace(/.(.?)/g,(_,c,j)=>s[j]+c))
Neil
la source
Agréable. J'ai eu f=([a,...A],[b,...B])=>a?[a+f(B,A)[0],b+f(A,B)[0]]:[""]pour la même longueur.
ETHproductions
J'espérais faire beaucoup mieux, mais pas moyen, juste un de moins. Il est temps d'
envoyer
@ edc65 Belle idée à utiliser map, il m'a supprimé 10 octets de ma réponse d'expressions rationnelles. Encore trop longtemps cependant.
Neil
2

Perl, 40 octets

Inclut +1 pour -n

Donne des chaînes sous forme de lignes sur STDIN

interlace.pl
hello
world
^D

interlace.pl

#!/usr/bin/perl -n
s/./${1&$.+pos}[pos]=$&/seg}{print@0,@1
Ton Hospel
la source
2

Java, 132 103 100 octets

Merci à Kevin Cruijssen d’avoir suggéré de retourner le tableau (parmi d’autres améliorations) et d’avoir économisé 29 octets! Aussi Olivier Grégoire pour 3 octets!

char[]c(char[]s,int l){for(int o=l;o-->0;)if(o%2>0){char t=s[o];s[o]=s[l+o+1];s[l+o+1]=t;}return s;}

Appelé comme ça:

public static void main(String[] args) {
    System.out.println(c("Hello,world!".toCharArray(), 5)); // 5 is the length of each "String"
}

Sortie:

Hollo,werld!

Tirant parti du fait que l’entrée peut en principe être formatée de quelque manière que ce soit (dans ce cas, un tableau de caractères unique de chaînes délimitées par une virgule), ainsi que des règles de sortie relativement indulgentes.

Hypino
la source
Bonjour, vous avez le format d'entrée original. Vous pouvez cependant jouer un peu plus: char[]c(char[]s,int l){for(int o=l,t;o-->0;)if(l%2>0){t=s[l];s[l]=s[l+o+1];s[l+o+1]=(char)t;}return s;}( 103 octets ) avec le résultat renvoyé au lieu d’être imprimé directement. Exemple de saisie System.out.println(c("Hello,world!".toCharArray(), 5));; Exemple de sortie: Hollo,werld!.
Kevin Cruijssen
C'est assez vrai, je n'avais pas envisagé de retourner le tableau de caractères pour une raison quelconque. C'est génial!
Hypino
Le résultat devrait être Hollo!werld,et non Hollo,werld!(la ponctuation est incorrecte). Je pense que cela peut être corrigé avec une valeur d'entrée de 6 au lieu de 5.
Olivier Grégoire
Puisque vous lancez tsur char, pourquoi ne le déclarez-vous pas directement dans la boucle for char? Vous épargnerez quelques octets pour le faire
Olivier Grégoire
Malheureusement, vous ne pouvez pas déclarer le caractère dans l'initialiseur de la boucle for, mais vous m'avez inspiré de vérifier si déclarer séparément le caractère serait plus court que la distribution et qu'il s'agit bien d'un octet.
Hypino
1

C, 124 octets

main(c,v)char**v;{char a[99],b[99];for(c=0;v[1][c]^0;++c){a[c]=v[1+c%2][c];b[c]=v[2-c%2][c];}a[c]=0;b[c]=0;puts(a);puts(b);}

Appeler avec:

program.exe string1 string2

La longueur de la chaîne est limitée à 98 caractères.

Steadybox
la source
1

Octave , 64 61 octets

@(x)reshape(x((t=1:end)+(2*mod(t,2)-1).*(mod(t-1,4)>1)),2,[])

Fonction anonyme qui entre un tableau de caractères 2D avec chaque chaîne d'une ligne et génère la sortie au même format.

Essayez chez Ideone .

Luis Mendo
la source
1

Raquette 208 octets

(let((sl string->list)(ls list->string)(r reverse))(let p((s(sl s))(t(sl t))(u'())(v'())(g #t))(if(null? s)
(list(ls(r u))(ls(r v)))(p(cdr s)(cdr t)(cons(car(if g s t))u)(cons(car(if g t s))v)(if g #f #t)))))

Ungolfed:

(define (f s t)
  (let ((sl string->list)                ; create short names of fns
        (ls list->string)
        (r reverse))
    (let loop ((s (sl s))                ; convert string to lists
               (t (sl t))
               (u '())                   ; create empty new lists
               (v '())
               (g #t))                   ; a boolean flag
      (if (null? s)                      ; if done, return new lists converted back to strings
          (list (ls (r u))
                (ls (r v)))
          (loop (rest s)
                (rest t)                 ; keep adding chars to new lists alternately
                (cons (first (if g s t)) u) 
                (cons (first (if g t s)) v)
                (if g #f #t))            ; alternate the boolean flag
          ))))

Essai:

(f "abcdef" "123456")

Sortie:

'("a2c4e6" "1b3d5f")

Ci-dessus est la version récursive.

Version itérative:

(let*((sl string->list)(ls list->string)(r reverse)(s(sl s))(t(sl t))(l'())(k'())(p(λ(a b g)(set! l(cons(if g a b)l))
(set! k(cons(if g b a)k)))))(for((i s)(j t)(n(in-naturals)))(p i j(if(= 0(modulo n 2)) #t #f)))(list(ls(r l))(ls(r k))))

Ungolfed:

(define (f s t)
  (let* ((sl string->list)              ; create short form of fn names
         (ls list->string)
         (r reverse)

         (s (sl s))                     ; convert strings to lists
         (t (sl t))

         (l '())                        ; create empty lists for new sequences
         (k '())

         (p (λ(a b g)                   ; fn to add chars to one or other list
              (set! l (cons (if g a b) l))
              (set! k (cons (if g b a) k)))))

    (for ((i s)(j t)(n (in-naturals)))  ; loop with both strings
          (p i j                        ; add to new lists alternately
             (if (= 0 (modulo n 2)) #t #f)))

    (list (ls (r l))                  ; convert reversed lists to strings
          (ls (r k)))))
rnso
la source
1

PowerShell v2 +, 82 octets

param($a,$b)$i=0;[char[]]$a|%{$c+=($_,$b[$i])[$i%2];$d+=($b[$i],$_)[$i++%2]};$c;$d

Je joue encore au golf ... Nope. Vous ne pouvez pas sembler jouer cela sans utiliser une regex comme d’autres réponses (boo on en copiant des algorithmes).

Nous prenons donc $aet en $btant que chaînes, définissons index $isur 0, transposons en $atant que char-array et l'envoyons via une boucle |%{...}. A chaque itération, nous concaténons des chaînes sur $cet $den indexant dans un tableau-select (c’est-à-dire qu’il alterne en arrière). Ensuite, nous partons $cet$d sur le pipeline, et la sortie via implicite Write-Outputse produit à la fin du programme.

AdmBorkBork
la source
1

Lithp , 120 caractères (+3 pour le drapeau -v1)

Ligne divisée en 2 pour plus de lisibilité:

#P::((invoke P "map" (js-bridge #W,I::(replace W (regex "." "g")
     (js-bridge #C,J::(index (index P (& (+ I J) 1)) J))))))

Nécessite le -v1 indicateur run.jscar certaines fonctions ne font pas encore partie de la bibliothèque standard.

Exemple d'utilisation:

(
    (def f #P::((invoke P "map" (js-bridge #W,I::(replace W (regex "." "g")
                (js-bridge #C,J::(index (index P (& (+ I J) 1)) J)))))))
    (print (f (list "Hello," "world!")))
)

Cela montre que je n'ai pas passé assez de temps sur la bibliothèque standard. Avoir à utiliserjs-bridge/1 deux fois et la forme regex longue, ainsi que d’appeler map en utilisant invoke/*tout, contribue à ce que cela dure beaucoup plus longtemps que nécessaire.

Je pense qu'il est temps de travailler sur ma bibliothèque standard.

Andrakis
la source
1

PHP, 79 octets

for(;$i<=strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])echo$a[1+$i%2][+$i]??" $y";

Version précédente PHP, 82 octets

for(;$i<strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])$x.=$a[1+$i%2][$i];echo"$x $y";
Jörg Hülsermann
la source
for(...)echo$a[1+$i%2][$i];echo" $y";(-2)
Titus
En se for(;$i<=strlen(($a=$argv)[1]);$y.=$a[2-$i%2][$i++])echo$a[1+$i%2][$i]??" $y";
basant sur
@ user59178 sympa mais il vous faut 1 octet de plus
Jörg Hülsermann
le faites vous? cela fonctionne pour moi, vous venez d'obtenir unNotice: String offset cast occurred in Command line code on line 1
user59178
@ user59178 Oui pour imprimer la première lettre du premier mot
Jörg Hülsermann
1

C, 54 52 octets

f(char*a,char*b,char*c){while(*c++=*a++,*c++=*b++);}

Suppose que la sortie ca déjà la longueur souhaitée.

Usage:

main(){
 char a[]="123456";
 char b[]="abcdef";
 char c[sizeof(a)+sizeof(b)-1];
 f(a,b,c);
 puts(c);

}

Si vous insistez pour créer la sortie, voici une solution de 91 octets :

char*g(char*a,char*b){char*c=malloc(2*strlen(a)),*d=c;while(*c++=*a++,*c++=*b++);return d;}

Usage:

main(){
 char a[]="123456";
 char b[]="abcdef";
 puts(g(a,b));
}
Karl Napf
la source
0

C, 150 octets

J'ai utilisé les omissions typiques des fichiers d'en-tête et main() du type de retour et de l'instruction de retour. Il jette un avertissement, mais compile sans problème. J'ai également utilisé une astuce spécifique à GCC qui permet les déclarations de tableau avec des expressions variables.

Le programme attend les chaînes de la ligne de commande et doit donc être exécuté avec ./a.out string1 string2.

main(int a,char**v){int x=strlen(v[1]);char s[x],t[x],c;strcpy(s,v[1]);strcpy(t,v[2]);for(a=0;a<x;++a)if(a%2)c=s[a],s[a]=t[a],t[a]=c;puts(s),puts(t);}

Ou plus lisiblement,

main(int a,char**v){
    int x=strlen(v[1]);
    char s[x],t[x],c;
    strcpy(s,v[1]);strcpy(t,v[2]);
    for(a=0;a<x;++a)
        if(a%2)c=s[a],s[a]=t[a],t[a]=c;
    puts(s),puts(t);
}
James Murphy
la source
0

Mathematica, 51 octets

Prend l'entrée sous forme de tableau de deux tableaux de caractères, avec une sortie au même format. La fonction construit simplement le nouveau tableau en utilisant une opération (mod 2).

Table[#[[Mod[j+i,2]+1,j]],{i,2},{j,Length@#[[1]]}]&
Greg Martin
la source
0

QBasic 4.5, 172 octets

Aïe, celui-ci devient douloureux avec le vieux QBasic ...

DEFSTR A-D:INPUT A,B
IF LEN(A)MOD 2=1 THEN A=A+" ":B=B+" "
FOR x=1 TO LEN(A) STEP 2
C=C+MID$(A,x,1)+MID$(B,x+1,1):D=D+MID$(B,x,1)+MID$(A,x+1,1):NEXT:?RTRIM$(C),RTRIM$(D)

Fait amusant: utiliser DEFSTRplus d'octets sauvegardés que le coût, car je pourrais maintenant les utiliser Aau lieu de a$.

Steenbergh
la source
0

QBIC , 112 octets

QBIC peut rationaliser une grande partie de la plate-forme QBasic, mais le MID$moteur principal doit toujours être exécuté dans QBasic car il manque une fonction de sous-chaîne à QBIC. Néanmoins, me sauve 60 octets.

;;_LA|~a%2=1|A=A+@ | B=B+C][1,a,2|X=X+$MID$(A$,b,1)+MID$(B$,b+1,1):Y$=Y$+MID$(B$,b,1)+MID$(A$,b+1,1)|]?_tX|,_tY|
Steenbergh
la source
MIND$=> MIN$en texte.
Pas que Charles
0

Java, 68 octets

(a,b)->{for(int i=a.length;--i>0;){char t=a[--i];a[i]=b[i];b[i]=t;}}

Ungolfed et test

import java.util.Arrays;
import java.util.Collection;
import java.util.function.BiConsumer;

public class Main {

  static BiConsumer<char[], char[]> func = (left, right) -> {
      for (int i = left.length; --i > 0;) {
        char temp = left[--i];
        left[i] = right[i];
        right[i] = temp;
      }
    };

  public static void main(String[] args) {
    test("Hello,","world!", "Hollo!", "werld,");
    test("code", "golf", "codf", "gole");
    test("happy", "angry", "hnpry", "aagpy");
  }

  private static void test(String left, String right, String x, String y) {
    char[] leftChars = left.toCharArray();
    char[] rightChars = right.toCharArray();
    func.accept(leftChars, rightChars);
    Collection mixed = Arrays.asList(new String(leftChars), new String(rightChars));
    if (mixed.containsAll(Arrays.asList(x, y))) {
      System.out.println("OK");
    } else {
      System.out.printf("NOK: %s, %s -> %s%n", left, right, mixed);
    }
  }
}
Olivier Grégoire
la source
0

APL, 12

{↓(⍳⍴⊃⍵)⊖↑⍵}

Explication: {...} définit une fonction, ⍵ est le bon argument. La prise (↑) crée une matrice à partir des deux chaînes, puis fait pivoter chaque colonne () n fois, où n est la partie entre parenthèses (). C'est défini comme l'iota de la longueur du premier argument. (Ex: longueur = 5 ==> 1 2 3 4 5). Ainsi, la première colonne est tournée une fois, la deuxième deux fois (pour revenir aux positions d'origine), la troisième colonne trois fois, etc.

Essayez-le sur tryapl.org

Moris Zucca
la source