Ispirato casualmente dall'aumento dei numeri mentre le lettere diminuiscono

Dato un elenco di lettere e numeri interi misti (es ['a', 2, 3, 'b']) aumentare le lettere di una posizione in alfabeto (avvolgimento in za a) e ridurre il numero di 1. Per l'esempio precedente, l'uscita dovrebbe essere ['b', 1, 2, 'c'].

• L'input può essere un elenco di tipo misto, una stringa delimitata, un elenco di stringhe, ecc.
• zva a finire a, ma 1va a 0, 0va a -1, ecc.
• L'input sarà sempre [a-z]e solo numeri interi. Puoi scegliere le lettere maiuscole [A-Z]come input se è più facile per te.
• L'ingresso è garantito non vuoto.
• L'input può contenere solo numeri o solo lettere.

Esempi:

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]

Regole e chiarimenti

• Input e output possono essere forniti con qualsiasi metodo conveniente .
• È possibile stampare il risultato su STDOUT o restituirlo come risultato di una funzione.
• L'output non deve avere lo stesso formato dell'input (ad esempio, è possibile prendere input come stringa e output come elenco).
• È accettabile un programma completo o una funzione.
• Se applicabile, puoi supporre che gli interi di input / output si adattino all'intervallo nativo della tua lingua int.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

05AB1E , 5 byte

<AAÀ‡

Provalo online!

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

Python 3 , 59 byte

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

Provalo online!

-1 byte grazie a Erik the Outgolfer

Perl 5 (-p), 17 byte

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

Provalo online!

Bonus 19-byter:

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

TIO . Questo presenta alcuni trucchi interessanti, ma non riesce a battere la soluzione semplice sopra.

Rubino , 34 byte

Per ogni elemento, prova a restituire l'elemento -1. Le stringhe non possono farlo, quindi si sbagliano e vengono raccolte dalla rescueclausola, che invece la chiama succper restituire la lettera successiva nell'alfabeto. succ"rotola" su ze ritorna aaperò, quindi prendiamo semplicemente il primo carattere nella stringa restituita.

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

Provalo online!

JavaScript (Node.js) , 55 byte

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

Provalo online!

Python 3 , 182 130 118 byte

-51 byte grazie a @AdmBorkBork e @Black Owl Kai, -1 byte grazie a @Black Owl Kai, -12 byte sostituendo .append()con +=[]e sostituendo n+1con-~n

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

Provalo online!

L'ho fatto mentre la domanda era nella Sandbox ma non l'ho vista pubblicata fino a ora. : P

Ungolfed

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

Spiegazione

Per ogni elemento nell'elenco immesso x, tenta di sottrarre 1 e aggiungerlo all'elenco restituito. Se si verifica un errore (poiché l'elemento è una stringa), l'indice della lettera nell'alfabeto viene aggiunto da 1 e viene presa la mod 26. La mod 26 riporta un indice di 26 a 0.

J , 30 byte

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

Provalo online!

Gema , 55 personaggi

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

Soluzione sporca. Avvolgere l'incremento delle lettere è dolorosamente lungo, quindi ho una regola separata.

L'input può essere praticamente qualsiasi cosa, basta usare alcuni separatori. (Puoi anche omettere separatori tra numeri e lettere. Con il prezzo di 1 carattere per passare a<L1> te potresti omettere anche i separatori tra le lettere.)

Esecuzione di esempio:

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

Provalo online!

Gema, 66 personaggi

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

Soluzione pulita. Metà relativamente efficiente, quindi metà dolore puro.

Esecuzione di esempio:

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

Provalo online!

R , 77 85 byte

Grazie @Giuseppe per un enorme 8 byte

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

Provalo online!

Prende l'input come un elenco. Dopo una grande modifica da parte di @Giuseppe, viene utilizzato Mapper applicare una funzione all'elenco. Usa matchper testare un personaggio. Durante il test l'elenco di lettere estese e l'indice vengono salvati per il reso.

MathGolf , 14 byte

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

Provalo online!

Prende la lettera in minuscolo.

Spiegazione

▄\╧              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

Retina , 52 50 48 58 41 37 byte

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

-4 byte grazie a @FryAmTheEggman (e per la menzione ho avuto un bug: 1 → -1invece di 1 → 0).
+10 byte per correggere un bug con 1e 0... Un caso così fastidioso che mi ha fregato per un bel po '.. Ma adesso ho giocato a 41 byte. (Ora sono curioso delle versioni <40 byte @Neil e @CowsQuack citate nei commenti .. Grazie @Neil per la punta di conversione 0in -, e di gestire prima i valori negativi. Conversione di quelli di ritorno da unari a interi aiutato molto.)
Apparentemente non ho bisogno dei limiti a questo punto, quindi -4 byte ..>.>

L'I / O è separato da virgola.

Provalo online.

Spiegazione:

Traslitterare tutto "zabcdefghijklmnopqrstuvwxy(z)"per "abcdefghijklmnopqrstuvwxyz":

T`zl`l

Sostituisci tutti i messaggi standalone 0con un -:

\b0
-

Converti tutti i numeri in unari, sostituendoli con quella quantità di caratteri di sottolineatura:

\d+
*

Per tutti i valori negativi, con zero o più linee unarie dietro: mantieni il segno meno e ottieni la lunghezza totale di questa corrispondenza (incluso il -), convertita nuovamente in un numero intero:

-_*
-$.0

Per quanto riguarda gli interi positivi: abbina un intero positivo abbinando una singola linea unaria, seguita da zero o più linee unarie. Quindi sostituiscili con la lunghezza di quel gruppo di acquisizione per rimuovere quella singola linea unaria e convertirli nuovamente in numeri interi contemporaneamente:

_(_*)
$.1

SNOBOL4 (CSNOBOL4) , 103 byte

	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

Provalo online!

PHP , 50 byte

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

Provalo online!

test

Emette lettere / numeri interi separati da _un separatore finale.

In PHP puoi incrementare direttamente le lettere, quindi ne ho approfittato. Ma zviene incrementato in aa, per convertirlo in a, (++$a)[0]viene utilizzato il quale genera solo il primo carattere del valore incrementato.

Japt -m , 13 12 byte

-1 byte grazie a Shaggy

;¤?UÉ:Cg8+Uc

Provalo

Spiegazione:

;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

Nota : ;si trasforma Cin alfabeto minuscolo

Haskell, 52 51 byte

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

Poiché Haskell non consente elenchi di tipi misti, lettere e numeri vengono presi e restituiti come stringhe.

Provalo online!

Controlla tutti gli elementi dell'elenco: se la stringa è "z", return "a"; se il primo carattere della stringa è>'`' (ovvero una lettera, non una cifra), restituisce il successore dei caratteri nella stringa; altrimenti deve essere un numero, quindi converti in un numero intero, sottrai 1 e trasformalo di nuovo in una stringa.

Modifica: -1 byte grazie a @cole.

Gelatina , 13 byte

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

Provalo online!

Correzione intelligente di Jonathan Allan .

Nota: questo non è un programma completo, il piè di pagina su TIO rende possibile l'input utilizzando un argomento della riga di comando per testare la funzione.

C ++ 17 (gcc) , 120 byte

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

Ecco fla funzione richiesta; lè sia il parametro di input che quello di output e si prevede che sia un contenitore di oggetti compatibili con std::variant<char, int>o viceversa.

Provalo online!

dzaima / APL, 21 20 byte

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

Provalo online!

-1 grazie a ngn.

K (oK) , 27 byte

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

Provalo online!

-8 grazie a ngn e dzaima :)

Incantesimi runici , 36 byte

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

Provalo online!

Il processo generale è leggere l'input, anteporre uno 0 (coercizione in stringa), riconvertire in un numero (il singolo carattere restituirà sempre -1), confrontarlo con l'input. Se lo stesso, deve essere un valore numerico, sottrarre 1 e stampare. Se non è lo stesso, deve essere un carattere, sottrai 1, confronta con {. Se inferiore a, stampa, altrimenti sostituiscilo con ae stampa.

Ripetere l'operazione fino a quando il programma non esegue uno stack underflow.

L'output è separato ;per salvare 1 byte (e ne ha uno finale). L'input è separato dallo spazio.

Stax , 17 byte

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

Esegui ed esegui il debug

Sembra che dovrebbe essere possibile abbreviare, ma non posso resistere all'opportunità di utilizzare una nuova funzionalità Stax dall'ultima versione.

Trattare l'intero input come una stringa:

1. Regex sostituisce le serie di cifre con eval(match) - 1 . Questa è la nuova funzionalità, poiché la sostituzione del blocco regex non è una stringa, ma un numero intero.
2. Regex sostituisce le sequenze di lettere traducendole ad anello attorno all'alfabeto minuscolo.

Python 3, 66 byte

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

Modificare:

Fino ad ora non ho visto la soluzione di Jitse. Il trucco di if ''! = I * 0 è fantastico!

C #, 148 byte

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

Link a Repl.it

Ungolfed:

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

Carbone , 16 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta input su STDIN, ogni riga è una singola lettera minuscola o un numero intero e genera output su righe separate su STDOUT. Spiegazione:

ＷＳ

Immettere ripetutamente da STDIN fino a raggiungere una riga vuota.

⟦

Crea questa espressione in uscita sulla propria riga.

⎇№βι

È una sottostringa dell'alfabeto minuscolo predefinito?

§β⊕⌕βι

In tal caso, stampa la lettera successiva indicizzata ciclicamente.

Ｉ⊖ι

Altrimenti decrementa il valore e torna alla stringa per la stampa implicita.

Zsh , 47 byte

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

Provalo online!

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 byte

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

Provalo online!

L'input è una NULLmatrice '\0'-terminata di stringhe -terminate, ad es {"a", "b", "c", "17", NULL}.

-7 byte grazie a @ceilingcat

Perl 6 , 31 byte

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

Provalo online!

Anonimo Qualunque lambda che associ ciascun elemento all'elenco e tenti di sottrarre uno da esso, altrimenti incrementandolo e prendendo il primo carattere nel caso in cui si zchiude aa.

T-SQL 2012, 61 byte

Sono necessarie lettere maiuscole nell'input.

Utilizzo della variabile di tabella come input.

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

Provalo online

SimpleTemplate, 80 byte

Questo è stato scritto su una lingua che ho creato.

A causa delle limitazioni nel compilatore, non posso più ridurlo.

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

E ora, non golfato:

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

E la spiegazione:

• {@each argv as value}- scorre tutti i valori in argv. ( argvcontiene tutti gli argomenti passati).
  Se as <var>non è presente, _viene assunta la variabile predefinita .
• {@if value is matches "@\d+@"}- verifica che valuecorrisponda all'espressione regolare "@\d+@".
• {@inc by -1 value} - incrementa il valore di -1 (sostanzialmente, un decremento).
• {@echo value, "\n"}e {@echol_}- echolgenera i valori passati e aggiunge una riga alla fine.
• {@else} - autoesplicativo
• {@inc by 1 value}- incrementa il valore di 1. Se by <value>manca, si presume che sia 1.
• {@echo value.0, "\n"}e {@echol_.0}- echolgenera i valori passati e aggiunge una riga alla fine.
  Questo è necessario a causa delle regole sfida: z wraps to a.
  Quando @incviene usato su una stringa, incrementa i caratteri e, una volta colpito z, si sposta a aa.
  L'output del primo personaggio soddisfa la sfida, al costo di 7 byte.
• {@/}- chiude quanto {@else}sopra (opzionale).
• {@/}- chiude quanto {@each}sopra (opzionale).

Puoi provare su: http://sandbox.onlinephpfunctions.com/code/7533641a0aa1fc8bf4699a9c758690de186b052f

Ogni argomento passato a render()sarà un nuovo valore che viene considerato.

Perl, 64 byte

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