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 code-golf , donc le code le plus court en octets pour chaque langue gagne.

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)

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']

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

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.

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']

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 \.

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

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

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 Ṛż¥.

Gelée , 9 8 6 octets

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

Zṙ"J$Z

Utilise le codage Jelly .

Essayez-le en ligne!

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.

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

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>

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.

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

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

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.

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.

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 .

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

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.

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.

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

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

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

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]]}]&

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$.

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|

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

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