Una sfida ogl-edocf


22

Ingresso

Una stringa mescolata non vuota composta da caratteri ASCII nell'intervallo .[32..126]

Produzione

L'output si ottiene applicando rotazioni successive alla stringa di input.

Per ogni lettera ( [a-zA-Z]) nella stringa di input, da sinistra a destra:

  • se la lettera è in maiuscolo, ruota tutti i caratteri prima di essa di una posizione a sinistra
  • se la lettera è in minuscolo, ruota tutti i caratteri prima di una posizione verso destra

Esempio

Input: "Annuncio Cb"

  • La prima lettera è una " C ". Dovremmo fare una rotazione a sinistra, ma non c'è carattere prima di questa " C ". Quindi, non c'è nulla da ruotare.
  • La lettera successiva è una " b ". Ruotiamo " C " verso destra. Poiché è un singolo personaggio, rimane invariato.
  • Il carattere " - " non attiva alcuna rotazione, in quanto non è una lettera.
  • La lettera successiva è una " A ". Ruotiamo " Cb- " a sinistra, che fornisce " Annuncio bC "
  • La quarta e ultima lettera è una " d ". Ruotiamo " b-CA " verso destra, che dà " Ab-C d"

Pertanto, l'output previsto è " Ab-Cd ".

Regole

  • Puoi prendere l'input come stringa o come matrice di caratteri, che può essere o meno la stessa cosa, a seconda della tua lingua.
  • È inoltre possibile generare una matrice di caratteri anziché una stringa.
  • Questo è

Casi 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 

Risposte:


5

Pyth, 21 20 byte

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

Provalo qui

Spiegazione

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.

È possibile utilizzare .Uper ridurre l'ingresso dal 2o valore. Ciò consente di abbandonare =kdall'inizio e )kdalla fine poiché sia ​​l'input che la stampa sono impliciti. Programma completo: .U+.>b-}ZG}Zr1GZ- link
Visto il


3

Gelatina , 14 byte

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

Un collegamento monadico che accetta un elenco di caratteri che produce un elenco di caratteri.

Provalo online! Oppure vedi la suite di test .

Come?

ØẠŒ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

Non conosco troppo bene Jelly, ma non dovrei Ifare lo stesso ḅ-di questo caso? Sembra funzionare qui , ma non nel tuo codice. Sono un po 'confuso perché. Inoltre, esiste un comando per inviare l'intero elenco come elementi separati allo stack in Jelly (aspetta, Jelly non è un linguaggio basato sullo stack, vero ...)? In tal caso, è possibile utilizzare una semplice sottrazione e, inoltre, non avrai bisogno del negato se non sbaglio (simile all'ultima modifica nella mia risposta 05AB1E).
Kevin Cruijssen,

1
Iproduce un elenco - aggiungi ŒṘ per vedere una rappresentazione completa . Quindi ØẠŒHċ€IṪN⁸ṙ;ð/funzionerebbe.
Jonathan Allan,

Ah ok, ha senso. Grazie per la spiegazione. Bella risposta tra l'altro, l'ho già votata ieri. :)
Kevin Cruijssen,

3

05AB1E , 18 17 16 14 byte

õsvy.uy.l-._y«

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

3

K4 , 43 33 byte

Soluzione:

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

Esempi:

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

Spiegazione:

Scorrere sulla stringa di input, ruotando l'uscita precedente di 1, -1 o 0 a seconda della sua posizione nell'elenco "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 (/)

Gli appunti:

  • -10 byte con ispirazione dalla soluzione 05AB1E

3

> <> , 45 43 byte

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

Provalo online!

Il fatto che> <> abbia la rotazione dello stack aiuta, ma non è necessario controllare il caso della lettera.

Spiegazione:

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

2

Haskell , 101 91 byte

-10 byte ispirati alla risposta di Curtis Bechtel (utilizzare '@'<c,c<'['sopra elem c['A'..'Z']e l'intervallo corrispondente per le lettere minuscole).

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

Provalo online!

Spiegazione / Non golf

L'operatore (!)prende una stringa non vuota xsu cui possiamo abbinare pattern e un carattere:

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

Ora possiamo ridurre la coda dell'input da sinistra a destra, iniziando dal primo carattere dell'input usando:

\b a -> b!a ++ [a]

2

Haskell , 122 92 byte

Grazie a BWO per i suggerimenti! Ho anche risparmiato molto adottando un approccio leggermente diverso rispetto alla mia risposta originale.

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

Provalo online!


Puoi scambiare il pattern-match di (#), usare ,over &&, use [l!!0,c]over head l:[c], 1>0invece di True, non devi contare f=e puoi assumere input non vuoti che salvano la l==[]guardia - salvandoti 13 byte: provalo online!
ბიმო

Btw. Ho usato l' isLowere isUppergolf in mia presentazione , mi auguro di stare bene con che altrimenti mi invertire la mia modifica.
ბიმო

@BWO Grazie per i suggerimenti e vai avanti!
Curtis Bechtel,

2

JavaScript (Node.js) , 116 102 byte

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

Provalo online!

Originale ( 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


Probabilmente è più breve da fare eval(`regex`)rispetto all'utilizzo del costruttore
Downgoat,

@Downgoat Temo che non sia così perché in questo caso sono necessarie le barre eval(`regex`), quindi -2 + 2 = 0 e quindi non aiuta a ridurre il numero di byte.
Shieru Asakoto,

@Downgoat Vale la pena usarlo eval()quando si usa almeno un flag: eval('/./g')è 3 byte più corto di RegExp('.','g').
Arnauld,

@Arnauld È vero, ma non uso bandiere qui.
Shieru Asakoto,

@ShieruAsakoto (Certo. Il mio commento è stato indirizzato principalmente a Downgoat per spiegare perché non vale la pena farlo qui.)
Arnauld

2

Rubino , 51 byte

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

Provalo online!

Input e output sono array di caratteri

Il trucco:

Il codice è piuttosto semplice, tranne forse la parte di rotazione:

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

x è un singolo carattere, che potrebbe essere una lettera, la prima espressione x=~/\W/restituisce nilse è una lettera e 0 altrimenti. Se è 0, abbiamo finito, altrimenti la logica orcontrolla la seconda espressione: ?_<=>xrestituisce -1 per le lettere maiuscole e 1 per le lettere minuscole. Quindi la rotazione è:

  • -1 (1 a sinistra) per le maiuscole
  • +1 (1 a destra) per le lettere minuscole
  • 0 (nessuna rotazione) se non è una lettera

2

Rosso , 110 byte

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]

Provalo online!

Spiegazione:

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 
]


2

Japt, 17 16 14 byte

Prende l'input come una matrice di caratteri, genera una stringa

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

Provalo


Spiegazione

 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?


1

Java 10, 149 119 byte

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

Risposta di Port of @ShieruAsakoto JavaScript , quindi assicurati di votarlo.

Provalo online.

Spiegazione:

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

1

Stax , 32 byte

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

Esegui ed esegui il debug

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

Molti scambi di stack che probabilmente non sono necessari. Mi piacerebbe davvero scendere di più, ma stavo lottando con l'ordinamento della pila. Forse qualcuno può capire se sono annoiati. Continuerò a lavorarci su.


1

Attache , 69 byte

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

Provalo online!

Spiegazione

Forma generale

La funzione è generalmente simile a questa:

~Fold[{...}]#Iota

Che si ripiega {...}su ciascun membro nell'intervallo da 0a #input - 1( Iota), iniziando con l'input come seme.

La funzione interiore

La seguente funzione è chiamato come f[building, index]e viene chiamato con ogni indice da 0a #inputesclusivo. @SplitAtchiama SplitAtquesti argomenti, suddividendo la stringa di input 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

In sostanza, questa funzione ruota la parte sinistra della stringa in base al primo carattere della parte destra.


1

Carbone , 20 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

FS

Scorri i caratteri di input.

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

Mappa sulla serie di caratteri raccolti finora, indicizzando ciclicamente i caratteri raccolti finora con l'indice incrementato o decrementato se il carattere corrente è rispettivamente maiuscolo o minuscolo. Questo completa la rotazione. Il carattere successivo viene quindi concatenato e il risultato assegnato alla stringa.

ω

Stampa il risultato.


1

R , 107 102 100 byte

Massiccio perché il manip di stringhe di R è voluminoso. Qualcuno può farlo sotto i 100?

-5 byte usando il trucco "imposta le variabili del ciclo su F per evitare l'inizializzazione".

-2 byte assumendo che tutti i caratteri siano stampabili e che utilizzino 2*!k%%97>25anziché 2*k%in%97:122per testare le lettere minuscole, usando la precedenza dell'operatore.

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

Provalo online!


1
Unisciti a noi (sono solo io in questo momento ...) nella chat room R golf per far rimbalzare alcune idee in giro! La mia ipotesi è che il pezzo di permutazione sia il più corto possibile con questo approccio ma non averlo provato da solo, non posso dirlo con certezza.
Giuseppe,

1

Japt , 25 23 byte

Mi arrendo, non posso accorciarlo

-2 byte da @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    

Provalo online!


Sfortunatamente, non riesco a trovare un modo più breve di fare éXè\a -Xè\Aneanche :-( Potresti salvare due byte cambiando il doppio spazio in a )e rimuovendo ©(virgola implicita significa che Uè ancora emesso)
ETHproductions

Salva altri 2 byte rilasciando ÃUe usando la -hbandiera.
Shaggy,

1

Retina , 67 64 58 byte

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

-9 byte grazie a @Neil rimuovendo i tre inutili ?che avevo aggiunto, oltre a quelli inutili nell'altro (.*)caso.

Provalo online o verifica tutti i casi di test . (NOTA: Output con una nuova riga finale. L'intestazione nella suite di test consiste nel testare ciascuna riga di input come un caso di test separato e il piè di pagina deve rimuovere quella nuova riga finale per un output più compatto.)

Spiegazione:

Prepara una nuova riga prima dell'input:

^
¶

Continua a sostituire finché riusciamo a trovare una corrispondenza:

+`

Tutto il resto sono tre diversi controlli uniti:

Se il carattere subito dopo la nuova riga è una lettera minuscola: ruota tutto prima della nuova riga una volta verso destra, quindi aggiungi quel carattere e la nuova riga:

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

Se il carattere subito dopo la nuova riga è una lettera maiuscola: ruota tutto prima della nuova riga una volta verso sinistra, quindi aggiungi quel carattere e la nuova riga:

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

Altrimenti (né una lettera minuscola né maiuscola): sposta semplicemente la nuova riga una volta verso destra per la successiva 'iterazione':

¶(.)
$1¶

Questi tre controlli di cui sopra sono uniti a istruzioni regex OR ( |) e sostituzioni di gruppi più grandi per farlo agire come if(lowercase) ... elseif(uppercase) ... else ...:


Non penso che tu abbia bisogno della ?s - se non c'è ancora nulla da ruotare, non importa se c'è una lettera.
Neil,

1
Inoltre, la sostituzione (.*)¶(.)con $1$2¶può essere semplificata alla sostituzione ¶(.)con $1¶poiché l'altra acquisizione non influisce sul risultato.
Neil,

@Neil Ah, certo grazie. -9 byte proprio lì! :)
Kevin Cruijssen,

1

MATL , 20 byte

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

Provalo online!

-4 byte grazie a Luis Mendo.

Converte maiuscolo / minuscolo / non lettera in [-1,0,1] (prima metà del programma). Applica il turno consecutivamente (seconda metà). Sto distruggendo il mio cervello se c'è un modo migliore per mappare maiuscole / minuscole su [-1,0,1] (vedi la seconda versione), e forse un modo per invertire immediatamente la stringa in modo da sbarazzarsi delle due wè necessario per il &).


1

C (clang) , 168 159 153 119 byte

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 grazie a @ceilingcat

Provalo online!


Suggerisci g=a[j=i++];islower(a[i])?bcopy(a,a+1,j)invece dia[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j)
ceilingcat il

0

Pyth, 16 byte

em=+.>k-F}RGrBd2

Provalo qui!

Spiegazione:

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.
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.