Contribution
Une chaîne mélangée non vide composée de caractères ASCII dans la plage .
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
OGL-edocfCode-golf
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!"
code-golf
string
code-golf
string
code-golf
string
parsing
brainfuck
code-challenge
python
hello-world
error-message
code-golf
string
code-golf
number
integer
counting
subsequence
code-golf
string
cipher
code-golf
array-manipulation
arithmetic
integer
matrix
code-golf
math
sequence
code-golf
restricted-source
pi
popularity-contest
cops-and-robbers
polyglot
popularity-contest
cops-and-robbers
polyglot
code-golf
file-system
king-of-the-hill
code-golf
number
sequence
integer
rational-numbers
string
code-challenge
source-layout
code-golf
ascii-art
king-of-the-hill
code-golf
array-manipulation
sorting
code-golf
string
code-golf
restricted-source
source-layout
tips
math
code-challenge
permutations
logic-gates
code-golf
number
random
integer
code-golf
math
code-golf
math
number
decision-problem
king-of-the-hill
python
board-game
code-challenge
brainfuck
busy-beaver
code-golf
number
cops-and-robbers
polyglot
obfuscation
answer-chaining
code-golf
number
integer
conversion
code-golf
string
parsing
code-golf
ascii-art
number
king-of-the-hill
javascript
code-golf
source-layout
radiation-hardening
code-golf
array-manipulation
matrix
code-golf
string
graph-theory
code-golf
array-manipulation
decision-problem
code-golf
string
ascii-art
code-golf
string
code-golf
array-manipulation
Arnauld
la source
la source
.U
pour réduire l'entrée à partir de la 2e valeur. Cela vous permet de supprimer=k
depuis le début et)k
depuis la fin car l'entrée et l'impression sont implicites. Programme complet:.U+.>b-}ZG}Zr1GZ
- lienPython 2 ,
1009895 octetsEssayez-le en ligne!
la source
Gelée , 14 octets
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?
la source
I
je 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).I
donne une liste - ajoutezŒṘ
pour voir une représentation complète . CelaØẠŒHċ€IṪN⁸ṙ;ð/
fonctionnerait aussi.05AB1E ,
18171614 octetsEssayez-le en ligne ou vérifiez tous les cas de test .
Explication:
la source
K4 ,
4333 octetsSolution:
Exemples:
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".
Remarques:
la source
> <> ,
4543 octetsEssayez-le en ligne!
Le fait que> <> ait une rotation de pile aide, mais ne pas avoir à vérifier la casse de la lettre.
Explication:
la source
Haskell ,
10191 octets-10 octets inspirés de la réponse de Curtis Bechtel (à utiliser
'@'<c,c<'['
surelem c['A'..'Z']
et sur la plage correspondante pour les lettres minuscules).Essayez-le en ligne!
Explication / Non golfé
L'opérateur
(!)
prend une chaîne non videx
sur laquelle nous pouvons faire correspondre un motif et un caractère: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:
la source
Haskell ,
12292 octetsMerci à BWO pour les suggestions! J'ai également économisé beaucoup en adoptant une approche légèrement différente de ma réponse d'origine.
Essayez-le en ligne!
la source
(#)
, utiliser,
plus&&
, utiliser[l!!0,c]
plushead l:[c]
,1>0
au lieu deTrue
, vous n'avez pas besoin de compterf=
et vous pouvez supposer une entrée non vide qui sauve lal==[]
garde - vous économisant 13 octets: essayez-le en ligne!isLower
et leisUpper
golf dans ma soumission , j'espère que cela vous convient sinon je vais inverser ma modification.JavaScript (Node.js) ,
116102 octetsEssayez-le en ligne!
Original (
116111106B)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
la source
eval(`regex`)
que d'utiliser le constructeureval(`regex`)
, donc -2 + 2 = 0 et donc cela n'aide pas à réduire le nombre d'octets.eval()
quand au moins un indicateur est utilisé:eval('/./g')
est 3 octets plus court queRegExp('.','g')
.Rubis , 51 octets
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 est un seul caractère, qui pourrait être une lettre, la première expression
x=~/\W/
renvoienil
s'il s'agit d'une lettre, et 0 sinon. Si c'est 0, nous avons terminé, sinon, la logiqueor
vérifie la deuxième expression:?_<=>x
renvoie -1 pour les majuscules et 1 pour les minuscules. La rotation est donc:la source
Rouge , 110 octets
Essayez-le en ligne!
Explication:
la source
Perl 6 , 47 octets
Essayez-le en ligne!
Fonctionne sur un tableau de caractères.
la source
Japt,
171614 octetsPrend l'entrée comme un tableau de caractères, produit une chaîne
Essayez-le
Explication
la source
Gelée , 19 octets
Essayez-le en ligne!
la source
Java 10,
149119 octetsPort de @ShieruAsakoto Réponse JavaScript , alors assurez-vous de le voter.
Essayez-le en ligne.
Explication:
la source
Stax , 32 octets
Exécuter et déboguer
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.
la source
Attaché , 69 octets
Essayez-le en ligne!
Explication
Forme générale
La fonction ressemble généralement à ceci:
Qui se replie
{...}
sur chaque membre dans la plage de0
à#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 de0
à#input
exclusif.@SplitAt
appelleSplitAt
ces arguments, divisant la chaîne d'entréeindex
.Essentiellement, cette fonction fait tourner la partie gauche de la chaîne en fonction du premier caractère de la partie droite.
la source
Fusain , 20 octets
Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:
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.
la source
R ,
107102100 octetsMassif 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>25
plutôt qu'en2*k%in%97:122
testant les minuscules, en utilisant la priorité de l'opérateur.Essayez-le en ligne!
la source
Japt ,
2523 octetsJ'abandonne, je ne peux pas le raccourcir
-2 octets de @ETHproductions
Essayez-le en ligne!
la source
é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'ilU
est toujours émis)ÃU
et en utilisant l'-h
indicateur.Rétine ,
676458 octets-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:
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:
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':
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 unif(lowercase) ... elseif(uppercase) ... else ...
:la source
?
s - s'il n'y a pas encore de rotation, peu importe qu'il y ait une lettre.(.*)¶(.)
par$1$2¶
peut être simplifié par le remplacement¶(.)
par$1¶
car l'autre capture n'affecte pas le résultat.MATL , 20 octets
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
w
est nécessaire pour le&)
.la source
C (tintement) ,
168159153119 octets-26 grâce à @ceilingcat
Essayez-le en ligne!
la source
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)
Pyth, 16 octets
Essayez-le ici!
Explication:
la source