Un défi ogl-edocf

22

Contribution

Une chaîne mélangée non vide composée de caractères ASCII dans la plage .[32..126]

Sortie

La sortie est obtenue en appliquant des rotations successives à la chaîne d'entrée.

Pour chaque lettre ( [a-zA-Z]) de la chaîne d'entrée, de gauche à droite:

  • si la lettre est en majuscule, faites pivoter tous les caractères devant elle d'une position vers la gauche
  • si la lettre est en minuscule, faites pivoter tous les caractères devant elle d'une position vers la droite

Exemple

Entrée: "Cb-Ad"

  • La première lettre est un " C ". Nous devrions faire une rotation vers la gauche, mais il n'y a pas de caractère avant ce " C ". Il n'y a donc rien à faire pivoter.
  • La lettre suivante est un " b ". Nous tournons " C " vers la droite. Comme il s'agit d'un seul caractère, il reste inchangé.
  • Le caractère " - " ne déclenche aucune rotation, car ce n'est pas une lettre.
  • La lettre suivante est un " A ". Nous tournons " Cb- " vers la gauche, ce qui donne " bC Ad"
  • La quatrième et dernière lettre est un " d ". Nous tournons " b-CA " vers la droite, ce qui donne " Ab-C d"

Par conséquent, la sortie attendue est " Ab-Cd ".

Règles

  • Vous pouvez prendre l'entrée comme une chaîne ou comme un tableau de caractères - qui peut ou non être la même chose, selon votre langue.
  • Vous pouvez également générer un tableau de caractères au lieu d'une chaîne.
  • Ceci est

Cas de test

"cbad" -> "abcd"
"ACBD" -> "ABCD"
"Cb-Ad" -> "Ab-Cd"
"caeBDF" -> "aBcDeF"
"aEcbDF" -> "abcDEF"
"ogl-edocf" -> "code-golf"
"W o,ollelrHd!" -> "Hello, World!"
"ti HIs SSta ET!" -> "tHis IS a tEST!"
Arnauld
la source

Réponses:

5

Pyth, 21 20 octets

VQ=k+.>k-}NG}Nr1GN)k

Essayez-le ici

Explication

VQ=k+.>k-}NG}Nr1GN)k
VQ                )      For each N in the input...
     .>k                 ... rotate k (initially '')...
        -}NG}Nr1G        ... by (N is lowercase) - (N is uppercase)...
    +            N       ... then append N...
  =k                     ... and update k.
                   k     Output the result.

la source
Vous pouvez utiliser .Upour réduire l'entrée à partir de la 2e valeur. Cela vous permet de supprimer =kdepuis le début et )kdepuis la fin car l'entrée et l'impression sont implicites. Programme complet: .U+.>b-}ZG}Zr1GZ- lien
Sok
4

Python 2 , 100 98 95 octets

f=lambda s,p='':s and f(s[1:],[p[x:]+p[:x]+s[0]for x in[s[0].isupper()-s[0].islower()]][0])or p

Essayez-le en ligne!

TFeld
la source
3

Gelée , 14 octets

ØẠŒHċ€ḅ-N⁸ṙ;ð/

Un lien monadique acceptant une liste de caractères qui donne une liste de caractères.

Essayez-le en ligne! Ou voir le suite de tests .

Comment?

ØẠŒHċ€ḅ-N⁸ṙ;ð/ - Link - list of characters
             / - reduce by:
            ð  -   a dyadic chain:  1st call is f(L=1stCharacter, R=2ndCharacter)
               -                    ...then calls are f(L=previousResult, R=nextCharacter)
ØẠ             -     alphabet characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
  ŒH           -     split in half = ["ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz"]
     €         -     for each:
    ċ          -       count occurrences (of R)
               -                          e.g.: 'W' -> [1,0]; 'c' -> [0,1]; '@' -> [0,0]
      ḅ-       -     convert from base -1             -1             1             0
        N      -     negate                            1            -1             0
         ⁸     -     chain's left argument (i.e. L)
          ṙ    -     rotate left by (the negate result)
           ;   -     concatenate R
Jonathan Allan
la source
Je ne connais pas trop Jelly, mais Ije ne devrais pas faire la même chose que ḅ-dans ce cas? Cela semble fonctionner ici , mais pas dans votre code. Je suis un peu confus pourquoi. De plus, existe-t-il une commande pour pousser les listes entières en tant qu'éléments séparés dans la pile dans Jelly (attendez, Jelly n'est pas un langage basé sur la pile, n'est-ce pas ...)? Dans ce cas, une simple soustraction peut être utilisée et vous n'aurez pas non plus besoin du négatif si je ne me trompe pas (similaire à la dernière modification dans ma réponse 05AB1E).
Kevin Cruijssen
1
Idonne une liste - ajoutez ŒṘ pour voir une représentation complète . Cela ØẠŒHċ€IṪN⁸ṙ;ð/fonctionnerait aussi.
Jonathan Allan
Ah ok, ça a du sens. Merci pour l'explication. Belle réponse btw, déjà voté hier. :)
Kevin Cruijssen
3

05AB1E , 18 17 16 14 octets

õsvy.uy.l-._y«

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

Explication:

õ            # Start with an empty string
 sv          # Loop over the characters `y` of the input
   y.u       #  Check if `y` is an uppercase letter (1 if truthy; 0 if falsey)
   y.l       #  Check if `y` is a lowercase letter (1 if truthy; 0 if falsey)
      -      #  Subtract them from each other
       ._    #  Rotate the string that many times (-1, 0, or 1) toward the left
   y«        #  Append the current character `y` to the string
             # (And implicitly output the string after the loop)
Kevin Cruijssen
la source
3

K4 , 43 33 octets

Solution:

""{.q.rotate[-/y in'.Q`A`a;x],y}/

Exemples:

q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"Cb-Ad"
"Ab-Cd"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ogl-edocf"
"code-golf"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ti HIs SSta ET!"
"tHis IS a tEST!"

Explication:

Itérer sur la chaîne d'entrée, en faisant tourner la sortie précédente de 1, -1 ou 0 selon sa position dans la liste "a-zA-Z".

""{.q.rotate[-/y in'.Q`A`a;x],y}/ / the solution
""{                            }/ / iterate (/) over, starting x as ""
                             ,y   / append y to
   .q.rotate[             ;x]     / rotate x by ...
                    .Q`A`a        / the lists "a..z" and "A..Z"
               y in'              / y in each (') alphabet?
             -/                   / subtract (-) over (/)

Remarques:

  • -10 octets en s'inspirant de la solution 05AB1E
streetster
la source
3

> <> , 45 43 octets

ii:2+7$.::&"`{"@)@(*?}"@["&::&@)@(*?{&!
ror

Essayez-le en ligne!

Le fait que> <> ait une rotation de pile aide, mais ne pas avoir à vérifier la casse de la lettre.

Explication:

i    Get first inputted character
 i   Get second. This is to prevent errors from rotating an empty stack
  :2+7$.      Jump to the second line if that was EOF
        ::&   Create copies of the input and store one in the register
           "`{"@)@(*     Check if the char is lower case
                    ?}   If so rotate the stack
                      "@["&::&@)@(*?{   Rotate the other way if uppercase
                                     &  Push the new char
                                      ! Skip the first i instruction
Skip to the second line on EOF
ro      Reverse the stack and output
r r     Cancel out the first reverse
 o      Output the rest of the stack
Jo King
la source
2

Haskell , 101 91 octets

-10 octets inspirés de la réponse de Curtis Bechtel (à utiliser '@'<c,c<'['sur elem c['A'..'Z']et sur la plage correspondante pour les lettres minuscules).

g(x:y)=foldl((<>pure).(!))[x]y
x@(a:b)!c|'`'<c,c<'{'=last x:init x|'@'<c,c<'['=b++[a]|0<1=x

Essayez-le en ligne!

Explication / Non golfé

L'opérateur (!)prend une chaîne non vide xsur laquelle nous pouvons faire correspondre un motif et un caractère:

x@(a:b) ! c
  | '`' < c, c < '{' = last x : init x  -- rotate x to the right by one
  | '@' < c, c < '[' = b ++ [a]         -- rotate x to the left by one
  | otherwise = x                       -- keep x as is

Maintenant, nous pouvons réduire la queue de l'entrée de gauche à droite, en commençant par le premier caractère de l'entrée en utilisant:

\b a -> b!a ++ [a]
ბიმო
la source
2

Haskell , 122 92 octets

Merci à BWO pour les suggestions! J'ai également économisé beaucoup en adoptant une approche légèrement différente de ma réponse d'origine.

l@(a:b)!c|'`'<c,c<'{'=last l:init l++[c]|'@'<c,c<'['=b++[a,c]|0<1=l++[c]
f(c:s)=foldl(!)[c]s

Essayez-le en ligne!

Curtis Bechtel
la source
Vous pouvez échanger la correspondance de modèle de (#), utiliser ,plus &&, utiliser [l!!0,c]plus head l:[c], 1>0au lieu de True, vous n'avez pas besoin de compter f=et vous pouvez supposer une entrée non vide qui sauve la l==[]garde - vous économisant 13 octets: essayez-le en ligne!
ბიმო
Btw. J'ai utilisé le isLoweret le isUppergolf dans ma soumission , j'espère que cela vous convient sinon je vais inverser ma modification.
ბიმო
@BWO Merci pour les suggestions, et allez-y!
Curtis Bechtel
2

JavaScript (Node.js) , 116 102 octets

f=(s,i=1)=>s[i]?f(s.replace(RegExp(`^(.)(.{${i}})(?=[A-Z])|^(.{${i}})(.)(?=[a-z])`),"$4$3$2$1"),i+1):s

Essayez-le en ligne!

Original ( 116 111 106B)

s=>Buffer(s).map((x,i)=>s=(t=s[S="slice"](i),i<2)?s:x>64&x<91?s[S](1,i)+s[0]+t:x>96&x<123?s[i-1]+s[S](0,i-1)+t:s)&&s

s=>Buffer(s).map((x,i)=>i<2|--x%32>25|x<64?s:s=[s[S="slice"](1,i)+s[0],s[i-1]+s[S](0,i-1)][+(x>95)]+s[S](i))&&s

s=>Buffer(s).map((x,i)=>!i|--x%32>25|x<64?s:s=(w=x>95,t=s.slice(1-w,i-w),w?s[i-1]+t:t+s[0])+s.slice(i))&&s

Shieru Asakoto
la source
C'est probablement plus court à faire eval(`regex`)que d'utiliser le constructeur
Downgoat
@Downgoat Je crains que ce ne soit pas le cas car les barres obliques sont nécessaires dans le cas de eval(`regex`), donc -2 + 2 = 0 et donc cela n'aide pas à réduire le nombre d'octets.
Shieru Asakoto
@Downgoat Il vaut la peine d'utiliser eval()quand au moins un indicateur est utilisé: eval('/./g')est 3 octets plus court que RegExp('.','g').
Arnauld
@Arnauld C'est vrai, mais je n'utilise pas de drapeaux ici.
Shieru Asakoto
@ShieruAsakoto (bien sûr. Mon commentaire était principalement adressé à Downgoat pour expliquer pourquoi cela ne vaut pas la peine de le faire ici.)
Arnauld
2

Rubis , 51 octets

->s{w=[];s.map{|x|w.rotate!(x=~/\W/||?_<=>x)<<x};w}

Essayez-le en ligne!

L'entrée et la sortie sont des tableaux de caractères

L'astuce:

Le code est assez simple, sauf peut-être la partie rotation:

(x=~/\W/||?_<=>x)

x est un seul caractère, qui pourrait être une lettre, la première expression x=~/\W/renvoie nils'il s'agit d'une lettre, et 0 sinon. Si c'est 0, nous avons terminé, sinon, la logique orvérifie la deuxième expression: ?_<=>xrenvoie -1 pour les majuscules et 1 pour les minuscules. La rotation est donc:

  • -1 (1 à gauche) pour les majuscules
  • +1 (1 à droite) pour les minuscules
  • 0 (pas de rotation) si ce n'est pas une lettre
GB
la source
2

Rouge , 110 octets

func[s][p: s forall s[if all[(a: first s)>#"@"a < #"["][move p back s]if all[a >#"`"a <#"{"][move back s p]]p]

Essayez-le en ligne!

Explication:

f: func [ s ] [
    p: s                                ; store the starting position of the string in p
    forall s [                          ; iterate through the entire string
        a: first s                      ; store the current character in a
        if all [ a > #"@" a < #"[" ] [  ; if `a` is a uppercase letter
            move p back s               ; move the starting char to the position before current
        ]
        if all [ a > #"`" a < #"{" ] [  ; if `a` is a lowercase letter
            move back s p               ; move the character before the current one to the start
        ]
    ]
    p                                   ; return the string 
]
Galen Ivanov
la source
2

Perl 6 , 47 octets

*.reduce:{|@$^a.rotate($^b~~/\w/&&'_'leg$b),$b}

Essayez-le en ligne!

Fonctionne sur un tableau de caractères.

nwellnhof
la source
Ah, j'aurais choisi d'utiliser cmp et uc / lc, mais cela fait 49 octets
Jo King
1
Darn, 48 octets Presque rattrapé
Jo King
2

Japt, 17 16 14 octets

Prend l'entrée comme un tableau de caractères, produit une chaîne

;rÏiXéCøY -BøY

Essayez-le


Explication

 rÏ                :Reduce by passing the current result (X) & the current element (Y) through a function
   i               :  Prepend to Y
    Xé             :  X rotated right by
;     B            :    Uppercase alphabet
       øY          :    Contains Y?
          -        :    Subtract
;          C       :    Lowercase alphabet
            øY     :    Contains Y?
Hirsute
la source
1

Java 10, 149 119 octets

s->{for(int i=1;i<s.length();)s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");return s;}

Port de @ShieruAsakoto Réponse JavaScript , alors assurez-vous de le voter.

Essayez-le en ligne.

Explication:

s->{                          // Method with String as both parameter and return-type
  for(int i=1;i<s.length();)  //  Loop `i` in the range [1, length)
    s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");
                              //   Rotate the substring of [0, i] either left or right
  return s;}                  //  Return the modified input-String as result
Kevin Cruijssen
la source
1

Stax , 32 octets

éG7[Æ┐äZ▬Θε♫∙~╞ÉH╔u╬←J╛ü╢(┼▒uX)Ü

Exécuter et déboguer

B]s{c97 123:bsaa|)sc65 91:bsaa|(s+c}fd  #Full program, unpacked, implicit input
B]s                                     #Unons-left, singleton, swap top 2 of stack
   {c                                   #Copy iterative letter
     97 123                             #Put 97 and 123 on stack(lower case)
           :bsaa                        #Check if iterative letter is between range, swap orientation back to proper order
                |)                      #Rotate if the letter is within range
                  sc                    #Swap top 2 and copy top
                    65 91               #Put 65 and 91 on stack (Capitals)
                         :bsaa          #Check if iterative letter is between range, swap orientation back to proper order
                              |(        #Rotate if the letter is within range
                                s+c     #swap, concat and copy
                                   }fd  #remove duplicate of original answer after loop and implicitly print

Beaucoup de permutation de pile, ce qui est probablement inutile. J'aimerais vraiment en savoir plus, mais j'avais du mal avec l'ordre de la pile. Peut-être que quelqu'un peut comprendre s'il s'ennuie. Continuera à y travailler.

Multi
la source
1

Attaché , 69 octets

~Fold[{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}@SplitAt]#Iota

Essayez-le en ligne!

Explication

Forme générale

La fonction ressemble généralement à ceci:

~Fold[{...}]#Iota

Qui se replie {...}sur chaque membre dans la plage de 0à #input - 1( Iota), en commençant par l'entrée en tant que graine.

La fonction intérieure

La fonction suivante est appelée as f[building, index]et est appelée avec chaque index de 0à #inputexclusif. @SplitAtappelle SplitAtces arguments, divisant la chaîne d'entrée index.

{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}
{                                               }    anonymous function taking the split string
                                                     e.g.: ["cd-", "Adf!"]
      _'sp                                           concat the input with a space
                                                     e.g.: ["cd-", "Adf!", " "]
                                                     (this is to handle index = 0)
 s'r.=                                               `s` is the first member, and `r` is the second
           Rotate[s,                         ]       rotate `s` by:
                                  ALPHA'alpha          over uppercase and lowercase alphabets:
                        Has&r[0]=>                       test if r[0] is in each alphabet
                                                       e.g.: [true, false]
                    &`-!                               subtract the second from the first
                                                       e.g.: (true - false) = 1 - 0 = 1
                                                     s is rotated according to the following map:
                                                       uppercase =>  1
                                                       symbol    =>  0
                                                       lowercase => -1
                                              +r     append the right portion of the string

Essentiellement, cette fonction fait tourner la partie gauche de la chaîne en fonction du premier caractère de la partie droite.

Conor O'Brien
la source
1

Fusain , 20 octets

FS≔⁺⭆ω§ω⁻⁺λ№αι№βιιωω

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

FS

Faites une boucle sur les caractères saisis.

≔⁺⭆ω§ω⁻⁺λ№αι№βιιω

Mappez sur la chaîne de caractères collectés jusqu'à présent, indexation cyclique dans les caractères collectés jusqu'à présent avec l'index incrémenté ou décrémenté si le caractère actuel est respectivement en majuscule ou en minuscule. Ceci termine la rotation. Le caractère suivant est ensuite concaténé et le résultat est affecté à nouveau à la chaîne.

ω

Imprimez le résultat.

Neil
la source
1

R , 107 102 100 octets

Massif car la manipulation des cordes de R est volumineuse. Quelqu'un peut-il obtenir moins de 100?

-5 octets en utilisant l'astuce "définir les variables de boucle sur F pour éviter l'initialisation".

-2 octets en supposant que tous les caractères sont imprimables et en utilisant 2*!k%%97>25plutôt qu'en 2*k%in%97:122testant les minuscules, en utilisant la priorité de l'opérateur.

function(x){for(k in u<-utf8ToInt(x))u[1:F-1]=u[(1:(F=F+1)+k%in%65:90-2*!k%%97>25)%%F];intToUtf8(u)}

Essayez-le en ligne!

J.Doe
la source
1
Venez nous rejoindre (c'est juste moi en ce moment ...) dans le salon de golf R pour faire rebondir quelques idées! Je suppose que la pièce de permutation est aussi courte que possible avec cette approche mais sans l'avoir essayé moi-même, je ne peux pas le dire avec certitude.
Giuseppe
1

Japt , 25 23 octets

J'abandonne, je ne peux pas le raccourcir

-2 octets de @ETHproductions

£=¯Y éXè\a -Xè\A)+UsYÃU

£=¯Y éXè\a -Xè\A)+UsYÃU     Full program. Implicit input U
£                           map each char
 =                          set U equal to:
  ¯Y                        U sliced to current mapped value
    éXè\a -Xè\A)            and rotated left or right 1 char
                +UsY        append the non-sliced U value
                      ÃU    Output U    

Essayez-le en ligne!

Luis felipe De jesus Munoz
la source
Malheureusement, je ne peux pas trouver un moyen plus court de le faire éXè\a -Xè\A:-( Vous pourriez économiser deux octets en changeant le double espace en a )et en le supprimant ©(une virgule implicite signifie qu'il Uest toujours émis)
ETHproductions
Enregistrez encore 2 octets en supprimant ÃUet en utilisant l' -hindicateur.
Shaggy
1

Rétine , 67 64 58 octets

^
¶
+`(.*)(.)¶([a-z])|(.)(.*)¶([A-Z])|¶(.)
$2$1$3$5$4$6$7¶

-9 octets grâce à @Neil supprimant les trois inutiles ?que j'avais ajoutés, ainsi que les inutiles(.*) dans le cas .

Essayez-le en ligne ou vérifiez tous les cas de test . (REMARQUE: sorties avec une nouvelle ligne de fin. L'en-tête de la suite de tests consiste à tester chaque ligne d'entrée en tant que scénario de test distinct et le pied de page supprime cette nouvelle ligne de fin pour une sortie plus compacte.)

Explication:

Ajoutez une nouvelle ligne avant l'entrée:

^
¶

Continuez à remplacer tant que nous pouvons trouver une correspondance:

+`

Tout le reste est constitué de trois contrôles différents fusionnés:

Si le caractère juste après la nouvelle ligne est une lettre minuscule: faites tout tourner avant la nouvelle ligne vers la droite, puis ajoutez ce caractère et la nouvelle ligne:

(.*)(.)¶([a-z])
$2$1$3¶

Si le caractère juste après la nouvelle ligne est une lettre majuscule: faites pivoter tout avant la nouvelle ligne vers la gauche, puis ajoutez ce caractère et la nouvelle ligne:

(.)(.*)¶([A-Z])
$2$1$3¶

Sinon (ni une lettre minuscule ni une lettre majuscule): déplacez simplement la nouvelle ligne une fois vers la droite pour la prochaine 'itération':

¶(.)
$1¶

Ces trois vérifications ci-dessus sont fusionnées avec des instructions regex OR ( |) et des remplacements de groupe plus importants pour le faire agir comme un if(lowercase) ... elseif(uppercase) ... else ...:

Kevin Cruijssen
la source
Je ne pense pas que vous ayez besoin du ?s - s'il n'y a pas encore de rotation, peu importe qu'il y ait une lettre.
Neil
1
De plus, le remplacement (.*)¶(.)par $1$2¶peut être simplifié par le remplacement ¶(.)par $1¶car l'autre capture n'affecte pas le résultat.
Neil
@Neil Ah, bien sûr merci. -9 octets juste là! :)
Kevin Cruijssen
1

MATL , 20 octets

ttYo-ZS"X@q:&)w@YSwh

Essayez-le en ligne!

-4 octets grâce à Luis Mendo.

Convertit les majuscules / minuscules / non-lettres en [-1,0,1] (première moitié du programme). S'applique consécutivement (deuxième mi-temps). Je suis en train de détruire mon cerveau s'il existe un meilleur moyen de mapper les majuscules / minuscules à [-1,0,1] (voir la deuxième version), et peut-être un moyen d'inverser immédiatement la chaîne afin de se débarrasser des deux west nécessaire pour le &).

Sanchises
la source
1

C (tintement) , 168 159 153 119 octets

g,i,j;f(char*a){for(i=0;a[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j),*a=g:isupper(a[i])?g=*a,bcopy(a+1,a,j),a[j]=g:0);}

-26 grâce à @ceilingcat

Essayez-le en ligne!

Logern
la source
Suggérer à la g=a[j=i++];islower(a[i])?bcopy(a,a+1,j)place dea[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j)
plafondcat
0

Pyth, 16 octets

em=+.>k-F}RGrBd2

Essayez-le ici!

Explication:

em=+.>k-F}RGrBd2dQ    Autofill variables
 m               Q    for each d in Q (the input):
            rBd2       Take [d, swapcase(d)]
         }RG           Figure out which are in the lowercase alphabet (returns [1,0] for lowercase, [0,1] for uppercase, [0,0] for non-letters)
       -F              Fold on subtraction (1 for lowercase, -1 for uppercase, 0 for non-letter)
    .>k                Cycle the processed part (k) of the input right by ^ steps
   +            d      Add in the new character at the end
  =   k                Store new process step back into k (k starts as an empty string)
e                     Get the (e)nd step's output.
Steven H.
la source