Inspiré au hasard par les nombres augmentent tandis que les lettres diminuent

Étant donné une liste de lettres mixtes et des nombres entiers (par exemple ['a', 2, 3, 'b']) augmenter les lettres d'une position dans l'alphabet (emballage à zla a) et diminuer le nombre de 1. Pour l'exemple ci - dessus, la sortie devrait être ['b', 1, 2, 'c'].

• L'entrée peut être une liste de type mixte, une chaîne délimitée, une liste de chaînes, etc.
• zretourne à a, mais 1va à 0, et 0va à -1, etc.
• L'entrée ne sera que des [a-z]nombres entiers. Vous pouvez choisir des majuscules [A-Z]en entrée si cela vous est plus facile.
• L'entrée est garantie non vide.
• L'entrée peut contenir uniquement des chiffres ou uniquement des lettres.

Exemples:

Input
Output

['a', 2, 3, 'b']
['b', 1, 2, 'c']

['a', 'b', 'z']
['b', 'c', 'a']

[-1, 0, 257, 'x']
[-2, -1, 256, 'y']

[0, 3, 1, 20382876]
[-1, 2, 0, 20382875]

Règles et clarifications

• L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
• Vous pouvez imprimer le résultat dans STDOUT ou le renvoyer en tant que résultat de fonction.
• La sortie ne doit pas nécessairement être au même format que l'entrée (par exemple, vous pouvez prendre l'entrée sous forme de chaîne et la sortie sous forme de liste).
• Un programme complet ou une fonction sont acceptables.
• Le cas échéant, vous pouvez supposer que les entiers d'entrée / sortie correspondent à la intplage native de votre langue .
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

05AB1E , 5 octets

<AAÀ‡

Essayez-le en ligne!

<          # decrement the numbers
 A         # constant "abcdefghijklmnopqrstuvwxyz"
  AÀ       # same, but rotated left ("bcd...yza")
    ‡      # transliterate

Python 3 , 59 octets

lambda a:[i-1if''!=i*0else chr(97+(ord(i)+8)%26)for i in a]

Essayez-le en ligne!

-1 octet grâce à Erik l'Outgolfer

Perl 5 (-p), 17 octets

y/a-z/b-za/or$_--

Essayez-le en ligne!

Bonus de 19 octets:

$_>$_++?$_-=2:s/a//

TIO . Celui-ci propose quelques astuces intéressantes, mais ne parvient pas à battre la solution simple ci-dessus.

Rubis , 34 octets

Pour chaque élément, essayez de renvoyer l'élément -1. Les chaînes ne peuvent pas faire cela, elles font donc une erreur et sont récupérées par la rescueclause, qui l'invite succà la place à renvoyer la lettre suivante de l'alphabet. succ"survole" zet revient aacependant, donc nous prenons simplement le premier caractère de la chaîne retournée.

->a{a.map{|e|e-1rescue e.succ[0]}}

Essayez-le en ligne!

JavaScript (Node.js) , 55 octets

a=>a.map(s=>1/s?s-1:B([(B(s)[0]+8)%26+97])+'',B=Buffer)

Essayez-le en ligne!

Python 3 , 182 130 118 octets

-51 octets grâce à @AdmBorkBork et @Black Owl Kai, -1 octet grâce à @Black Owl Kai, -12 octets en remplaçant .append()par +=[]et en remplaçant n+1par-~n

def a(x):
 b='abcdefghijklmnopqrstuvwxyz';c=[]
 for d in x:
  try:c+=[d-1]
  except:c+=[b[(-~b.find(d)%26)]]
 return c

Essayez-le en ligne!

Je l'ai fait pendant que la question était dans le bac à sable, mais je ne l'ai pas vue jusqu'à maintenant. : P

Non golfé

def a(x):
    b = 'abcdefghijklmnopqrstuvwxyz'
    c = []
    for d in x:
        try:
            c.append(d - 1)
        except:
            c.append(b[((b.find(d) + 1) % 26)])
    return c

Explication

Pour chaque élément de la liste entrée x, il essaie de soustraire 1 et de l'ajouter à la liste éventuellement renvoyée. Si une erreur se produit (car l'élément est une chaîne), l'index de la lettre dans l'alphabet est ajouté par 1 et ce mod 26 est pris. Le mod 26 enveloppe un index de 26 à 0.

J , 30 octets

<: ::((26|>:)&.(_97+a.i.]))&.>

Essayez-le en ligne!

Gema , 55 personnages

<N>=@sub{$1;1}
z=a
<L>=@int-char{@add{@char-int{$1};1}}

Solution sale. S'enrouler autour de l'incrément de lettre est douloureusement long, donc nous avons une règle distincte.

L'entrée peut être n'importe quoi, utilisez simplement des séparateurs. (Vous pouvez même omettre les séparateurs entre les chiffres et les lettres. Avec le prix d'un caractère pour passer à<L1> vous pouvez également omettre les séparateurs entre les lettres.)

Exemple d'exécution:

bash-5.0$ gema '<N>=@sub{$1;1};z=a;<L>=@int-char{@add{@char-int{$1};1}}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']

Essayez-le en ligne!

Gema, 66 caractères

<N>=@sub{$1;1}
<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}

Solution propre. Moitié relativement efficace, puis moitié pure douleur.

Exemple d'exécution:

bash-5.0$ gema '<N>=@sub{$1;1};<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']

Essayez-le en ligne!

R , 77 85 octets

Merci @Giuseppe pour une coqueluche de 8 octets

function(l)Map(function(x)"if"(i<-match(x,L<-c(letters,"a"),0),L[i+1],x-1),l)

Essayez-le en ligne!

Prend l'entrée comme une liste. Après un gros changement de @Giuseppe, cela permet d' Mapappliquer une fonction à la liste. Il utilise matchpour tester un personnage. Pendant le test, la liste de lettres étendue et l'index sont enregistrés pour le retour.

MathGolf , 14 octets

▄\╧¿ò'z=¿Å'a)(

Essayez-le en ligne!

Prend la lettre en minuscule.

Explication

▄\╧              Is the element in the lowercase alphabet?
   ¿ò            If so:
     'z=           Is it equal to z?
        ¿Å         If so:
          'a         Push 'a'
            )      Else: Increment the string
             (   Else: Decrement the number

Rétine , 52 50 48 58 41 37 octets

T`zl`l
\b0
-
\d+
*
-_*
-$.0
_(_*)
$.1

-4 octets grâce à @FryAmTheEggman (et pour avoir mentionné que j'avais un bug: 1 → -1au lieu de 1 → 0).
+10 octets pour corriger un bug avec 1et 0.. Un tel cas de bord ennuyeux qui m'a foutu pendant un bon moment .. Mais il a joué à 41 octets maintenant. (Maintenant , je suis curieux de savoir les <40 octets versions @Neil et @CowsQuack mentionnés dans les commentaires .. Merci @Neil pour la pointe de la conversion du 0à -, et de traiter les valeurs négatives en premier. La conversion de ceux qui reviennent droit unaire à l' entier beaucoup aidé.)
Apparemment, je n'ai pas besoin des limites à ce stade, donc -4 octets ..>.>

Les E / S sont séparées par des virgules.

Essayez-le en ligne.

Explication:

Translittérer tout "zabcdefghijklmnopqrstuvwxy(z)"vers "abcdefghijklmnopqrstuvwxyz":

T`zl`l

Remplacez tous les autonomes 0par un -:

\b0
-

Convertissez tous les nombres en unaire, en les remplaçant par ce nombre de soulignements:

\d+
*

Pour toutes les valeurs négatives, avec zéro ou plusieurs lignes unaires derrière lui: conservez le signe moins et obtenez la longueur totale de cette correspondance (y compris le -), reconvertie en entier:

-_*
-$.0

En ce qui concerne les entiers positifs: faites correspondre un entier positif en faisant correspondre une seule ligne unaire, suivie de zéro ou plusieurs lignes unaires. Et puis remplacez-les par la longueur de ce groupe de capture pour supprimer cette seule ligne unaire et les reconvertir simultanément en entiers:

_(_*)
$.1

SNOBOL4 (CSNOBOL4) , 103 octets

	U =&UCASE 'A'
N	X =INPUT	:F(END)
	U X @P	:F(D)
	U POS(P) LEN(1) . OUTPUT	:(N)
D	OUTPUT =X - 1	:(N)
END

Essayez-le en ligne!

PHP , 50 octets

for(;''<$a=$argv[++$i];)echo$a<a?--$a:(++$a)[0],_;

Essayez-le en ligne!

Les tests

Génère des lettres / entiers séparés par _un séparateur de fin.

En PHP, vous pouvez incrémenter des lettres directement, alors j'en ai profité. Mais le zest incrémenté en aa, pour le convertir en a, le (++$a)[0]est utilisé qui ne sort que le premier caractère de la valeur incrémentée.

Japt -m , 13 12 octets

-1 octet grâce à Shaggy

;¤?UÉ:Cg8+Uc

Essayez-le

Explication:

;o ?UÉ:Cg8+Uc
-m              // Map U through the input:
 o              // Try to create a range [1...U]
   ?            //   If that creates a range (number):
    UÉ          //     Return U-1
      :         //   Else, return:
;      C        //     alphabet (a...z)
        g       //     Index:
         8+Uc   //       8 + char-code of U

Remarque : se ;transforme Cen alphabet minuscule

Haskell, 52 51 octets

map q
q"z"="a"
q x|x>"`"=succ<$>x|1<2=show$read x-1

Comme Haskell n'autorise pas les listes de types mixtes, les lettres et les chiffres sont pris et renvoyés sous forme de chaînes.

Essayez-le en ligne!

Vérifiez chaque élément de la liste: si la chaîne est "z", return "a"; si le premier caractère de la chaîne est>'`' (c'est-à-dire une lettre, pas un chiffre), retournez le successeur du ou des caractères dans la chaîne; sinon, il doit être un nombre, alors convertissez-le en entier, soustrayez 1 et transformez-le à nouveau en chaîne.

Edit: -1 octet grâce à @cole.

Gelée , 13 octets

®i‘ị®µ’e?€Øa©

Essayez-le en ligne!

Solution intelligente de Jonathan Allan .

Remarque: Ce n'est pas un programme complet, le pied de page sur TIO permet de saisir à l'aide d'un argument de ligne de commande pour tester la fonction.

C ++ 17 (gcc) , 120 octets

#define O int operator()
struct V{O(char&c){c++-90?:c=65;}O(int&i){--i;}};int f(auto&l){for(auto&x:l)std::visit(V{},x);}

Voici fla fonction requise; lest à la fois le paramètre d'entrée et de sortie, et il devrait être un conteneur d'objets compatibles avec std::variant<char, int>ou vice versa.

Essayez-le en ligne!

dzaima / APL, 21 20 octets

{0::⍵-1⋄⎕l(⍳⊇1⌽⊣)⍵}¨

Essayez-le en ligne!

-1 grâce à ngn.

K (oK) , 27 octets

{$[9+@x;`c$97+26!8+x;x-1]}'

Essayez-le en ligne!

-8 merci à ngn et dzaima :)

Enchantements runiques , 36 octets

\$ka'~?*3({':+1\
R';$ >i::0Sqn=?/1-$

Essayez-le en ligne!

Le processus général consiste à lire l'entrée, à ajouter un 0 (coercition en chaîne), à ​​reconvertir en nombre (le caractère unique renvoie toujours -1), à comparer avec l'entrée. S'il s'agit du même, il doit s'agir d'une valeur numérique, soustrayez 1 et imprimez. Sinon, il doit s'agir d'un caractère, soustrayez 1, comparez avec {. Si moins que, imprimez, sinon remplacez-le par aet imprimez.

Répétez jusqu'à ce que le programme effectue un sous-dépassement de pile.

La sortie est séparée par ;afin d' économiser 1 octet (et en a un de fin). L'entrée est séparée par des espaces.

Stax , 17 octets

àºÇ╝'♫d▬♣ΩÜEƒ6╩╬ó

Exécuter et déboguer

On dirait qu'il devrait être possible de faire plus court, mais je ne résiste pas à l'opportunité d'utiliser une nouvelle fonction stax de la dernière version.

Traiter l'entrée entière comme une chaîne:

1. Regex remplace les séries de chiffres par eval(match) - 1 . Il s'agit de la nouvelle fonctionnalité, car le remplacement de bloc d'expression régulière n'est pas une chaîne, mais un entier.
2. Regex remplace les séries de lettres en les traduisant en anneau autour de l'alphabet minuscule.

Python 3, 66 octets

lambda X:[x-1if type(x)==int else chr(97+(ord(x)+8)%26)for x in X]

Éditer:

Je n'ai pas vu la solution de Jitse jusqu'à présent. L'astuce si ''! = I * 0 est génial!

C #, 148 octets

(object[] o)=>{var l=new List<object>();foreach(var h in o){try{l.Add((int)h-1);}catch{var c=((char)h+1);if(c>122){c=97;}l.Add((char)c);}}return l;}

Lien Repl.it

Non golfé:

var inputList = new object[] {'a', 2, 'z', 6};
var outputList = new List<object>();
foreach (var currentItem in inputList)
{
    try
    {
        outputList.Add((int)currentItem-1);
    }
    catch
    {
        var currentItemPlusOne = ((char)currentItem + 1);
        if (currentItemPlusOne > 122)
        {
            currentItemPlusOne = 97;
        }
        outputList.Add((char)currentItemPlusOne);
    }
}

Fusain , 16 octets

ＷＳ⟦⎇№βι§β⊕⌕βιＩ⊖ι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend des entrées sur STDIN, chaque ligne étant soit une seule lettre minuscule ou un entier, et sort sur des lignes distinctes sur STDOUT. Explication:

ＷＳ

Saisie répétée de STDIN jusqu'à ce qu'une ligne vide soit atteinte.

⟦

Faites sortir cette expression sur sa propre ligne.

⎇№βι

S'agit-il d'une sous-chaîne de l'alphabet minuscule prédéfini?

§β⊕⌕βι

Si c'est le cas, imprimez la lettre suivante indexée cycliquement.

Ｉ⊖ι

Sinon, décrémentez la valeur et convertissez-la en chaîne pour une impression implicite.

Zsh , 47 octets

a=({a..z} a)
for i
<<<${a[$a[(i)$i]+1]:-$[--i]}

Essayez-le en ligne!

a=({a..z} a)                  # append extra 'a' to the end to handle 'z' case
for i                         # for i in "$@" arguments
<<<${a[$a[(i)$i]+1]:-$[--i]}
       $a[(i)$i]              # first (i)ndex of $i in list (if not found, set to after last index)
      [         +1]           # increment
   ${a[           ]        }  # value in array at index. if lookup fails, empty string
   ${              :-$[--i]}  # if empty, decrement $i and substitute instead
<<<                           # print to stdout

C (gcc) , 93 86 octets

f(int**s){for(char**p=s,*z;z=*p++;)64&*z?*z=*z-'z'?++*z:97:sprintf(z,"%d",atoi(z)-1);}

Essayez-le en ligne!

L'entrée est un NULLtableau '\0'terminé de chaînes terminées, par exemple{"a", "b", "c", "17", NULL} .

-7 octets grâce à @ceilingcat

Perl 6 , 31 octets

*>>.&{(try $_-1)||chr ord ++$_}

Essayez-le en ligne!

Anonymous Quel que soit le lambda qui mappe chaque élément à la liste et tente d'en soustraire un, sinon l'incrémenter et prendre le premier caractère dans le cas qui zrevient à aa.

T-SQL 2012, 61 octets

Des majuscules sont nécessaires en entrée.

Utilisation d'une variable de table comme entrée.

SELECT iif(x<'a',left(x-1,9),char((ascii(x)-64)%26+65))FROM @

Essayez-le en ligne

SimpleTemplate, 80 octets

Ceci a été écrit dans une langue que j'ai créée.

En raison des limitations du compilateur, je ne peux plus le réduire.

{@eachargv}{@if_ is matches"@\d+@"}{@incby-1_}{@echol_}{@else}{@inc_}{@echol_.0}

Et maintenant, non golfé:

{@each argv as value}
    {@if value is matches "@\d+@"}
        {@inc by -1 value}
    {@else}
        {@inc by 1 value}
    {@/}
    {@echo value, "\n"}
{@/}

Et l'explication:

• {@each argv as value}- boucle toutes les valeurs dans argv. ( argvcontient tous les arguments passés).
  Si le as <var>n'est pas présent, la valeur par défaut_ variable est supposée.
• {@if value is matches "@\d+@"}- vérifie qui valuecorrespond à l'expression régulière "@\d+@".
• {@inc by -1 value} - incrémente la valeur de -1 (fondamentalement, une décrémentation).
• {@echo value, "\n"}et {@echol_}- echolsort les valeurs passées et ajoute une ligne à la fin.
• {@else} - explicite
• {@inc by 1 value}- incrémente la valeur de 1. Si le by <value>est manquant, il est supposé être 1.
• {@echo value.0, "\n"}et {@echol_.0}- echolsort les valeurs passées et ajoute une ligne à la fin.
  Cela est nécessaire en raison des règles de défi: z wraps to a.
  Quand un @incest utilisé sur une chaîne, il incrémente les caractères et, une fois qu'il frappe z, il passe à aa.
  La sortie du premier caractère répond au défi, au prix de 7 octets.
• {@/}- ferme ce qui {@else}précède (facultatif).
• {@/}- ferme ce qui {@each}précède (facultatif).

Vous pouvez essayer ceci sur: http://sandbox.onlinephpfunctions.com/code/7533641a0aa1fc8bf4699a9c758690de186b052f

Chaque argument passé à render()sera une nouvelle valeur prise en compte.

Perl, 64 octets

foreach (@ARGV){$_=~m/[a-zA-Z]/?++$_:--$_;print substr $_,0,1;}