ssTTsSTtRrriinInnnnNNNIiinngg

18

Sfida

Per ogni carattere della stringa tranne l'ultimo, procedi come segue:

  • Emette il carattere corrente.

  • Seguito dall'output casuale dall'elenco seguente un numero casuale di volte compreso tra 1 e 5 (incluso):

    • Il personaggio attuale
    • Il prossimo carattere della stringa
    • La versione switchcase del personaggio in cui ti trovi attualmente
    • La versione switchcase del prossimo carattere della stringa.

Casi test

String -> SSSTSStrTrIiinIIngn

, . , . , . Hello world! -> ,,, .. , ,, .... , , .. .. . HHH HHEeelLlLllooO wwOworOOrrrRllDd!!D

Programming Puzzles and Code Golf -> PrPPrRrOooooogggRgGraAraaaMMMmmmimMIiininGGgG PPPPuZzZZzZzzZzllLLEEeEsEsssS a aANnNddD C COCoooOOdeDe E GGGoOllFFf

Appunti

  • Devi solo applicare la versione switchcase di un personaggio se il personaggio fa parte dell'alfabeto (AZ e az).
  • La tua funzione casuale non deve essere uniforme, ma deve comunque avere la possibilità di restituire qualsiasi elemento nell'elenco fornito.
  • È consentito utilizzare qualsiasi formato I / O standard.
  • Si può presumere che la lunghezza dell'input sia maggiore o uguale a due.
  • Si può presumere che l'input sia composto solo da caratteri ASCII.
  • Il titolo non è un caso di test (non è involontario se si tratta di un caso di test valido).
  • Switchcase significa trasformare il carattere in minuscolo se è maiuscolo e trasformarlo in maiuscolo se è minuscolo.
code-golf  string  random 
— MilkyWay90
fonte
Oltre a "... non ha bisogno di essere uniforme", penso che probabilmente vorrai specificare che, dato un certo input, in linea di principio tutti gli output legali finiti dovrebbero essere in grado di generare (altrimenti, il mio intero casuale non uniforme in [1 , 2,3,4,5] sarà sempre 2 e visualizzerò semplicemente la stringa originale).
— Chas Brown,
@ChasBrown Sì, modificherò la domanda
— MilkyWay90,
2
Trovo la specifica confusa. Puoi essere più esplicito? Ad esempio, scopri come StringproduceSSSTSStrTrIiinIIngn
— Luis Mendo il
7
@LuisMendo Non sono OP, ma penso:, in [S]SSTSS [t]rT, [r]I, [i]inII, [n]gncui i personaggi tra i blocchi sono i primi punti elenco (" Emetti il ​​carattere corrente "), e gli altri personaggi sono 1-5 volte a caso una delle quattro scelte per quello personaggio. Ma sono d'accordo, alcune spiegazioni più esplicite sarebbero appropriate. A parte il caso di test non era particolarmente chiaro, dobbiamo scegliere una scelta casuale 1-5 volte. Invece di scegliere una scelta casuale ripetuta 1-5 volte (come attualmente fa la risposta di Gaia).
— Kevin Cruijssen,
3
@KevinCruijssen Grazie, la tua spiegazione si adatta all'esempio ed è chiara. L'OP dovrebbe confermare e modificarlo nel testo
— Luis Mendo,

Risposte:

6

Gaia , 25 byte

ṇ\+†ṅ\⟨)₌¤:~+4ṛ⟨ṛ₌¤⟩ₓ\⟩¦$

Provalo online!

Grazie a Kevin Cruijssen per aver segnalato 2 bug!

ṇ\				| delete the last character from the input
  +†				| push the input again and concatenate together, so for instance
				| 'abc' 'bc' becomes ['ab' 'bc' 'c']
    ṅ\				| delete the last element
       ⟨       		⟩¦	| for each of the elements, do:
	)₌			| take the first character and push again
	  ¤			| swap
	   :			| dup
	    ~			| swap case
	     +			| concatenate strings
	      4ṛ		| select a random integer from [1..5]
	        ⟨    ⟩ₓ		| and repeat that many times
		 ṛ₌¤		| select a random character from the string
		      \ 	| clean up stack
			   $	| convert to string

Si noti che 4ṛè perché ṛè implementato per un numero intero zcome Python random.randint(1,z+1), che restituisce un numero intero Ntale 1<=N<=z+1.

— Giuseppe
fonte
Sei sicuro che la codifica della lunghezza di esecuzione sia corretta qui? Se capisco correttamente la sfida: le quattro opzioni dovrebbero essere scelte 1-5 volte in modo casuale, invece di scegliere una delle quattro casualmente, ripetute 1-5 volte. Il primo esempio output SSSTSStrTrIiinIIngn( [SSSTSS, trT, rI, iinII, ngn]) sembra riflettere questo, e attualmente non è un possibile output nel tuo programma (credo).
— Kevin Cruijssen,
@KevinCruijssen Ho interpretato "l'output dall'elenco un numero casuale di volte" per indicare la decodifica della lunghezza di esecuzione, ma hai ragione, i casi di test sembrano indicare l'altra interpretazione; Penso che dovrebbe essere abbastanza facile da risolvere
— Giuseppe
1
5ṛpuò risultare 6per qualche motivo Provalo online ? PS: Non c'è un numero intero nella lista a distanza, o ha un intervallo for-loop in Gaia?
— Kevin Cruijssen,
1
@KevinCruijssen dang, Business Cat ha davvero bisogno di correggere gli errori off-by-one ... Pensavo davvero che ci fosse un forcostrutto di tipo, ma sono abbastanza sicuro ₓche non sia nemmeno documentato sulla pagina wiki.
— Giuseppe,
4

APL (dzaima / APL) , 23 byte

Funzione prefisso tacito anonimo.

∊2(⊣,{?4⍴⍨?5}⊇,,-⍤,)/

Provalo online!

2(... )/ applica la seguente funzione tacit di infissione tra ciascuna coppia di caratteri:

 - il commutatore
 ⍤ della
 , concatenazione della coppia

 ,, anteporre la concatenazione della coppia a quella

 {... }⊇ scegli i seguenti elementi da quello:

  ?5 numero casuale nell'intervallo 1… 5

  4⍴⍨ che tanti fours

  ? indici casuali per quelli

∊ ϵ nlist (appiattisci)

— Adamo
fonte
3

Perl 6 , 60 byte

{S:g{.)>(.)}=$/~[~] roll ^5 .roll+1,$/.lc,$/.uc,$0.lc,$0.uc}

Provalo online!

La parte minuscola / maiuscola è piuttosto fastidiosa.

— Jo King
fonte
Non conosco Perl, quindi probabilmente sto dicendo qualcosa di stupido qui. Ma è in qualche modo possibile concatenare il $/e $0insieme e usarlo .lcsu quella stringa, quindi creare una copia di quella stringa e usare .uce concatene quei due insieme? Non sono sicuro se questo è ancora possibile, o più breve di quello attuale $/.lc,$/.uc,$0.lc,$0.uc, ma sarà di usereste $/, $0, .lc, e .ucuna volta ciascuno.
— Kevin Cruijssen,
1
Ahimè, (.lc~.uc for $0~$/).combè più lungo. Perl 6 vuole davvero distinguere stringhe ed elenchi, quindi "abc"[0] eq "abc"(finge di essere un elenco di elementi singoli).
— Ven
Puoi farlo scivolando e una funzione anonima applicata a un elenco: {.lc,|.uc}($/,|$0)per -5 byte e usa solo l'elenco delle corrispondenze {.lc,|.uc}(@$/)per -8 byte. tio.run/…
— Phil H
@PhilH No, non funziona. Queste soluzioni capitalizzano solo una delle lettere ciascuna
— Jo King,
3

Bash , 121 byte

-20 byte grazie a Nahuel

-9 byte grazie a roblogic

for((i=0;i<${#1};i++)){
s=${1:i:1}
m=${1:i:2}
m=${m,,}${m^^}
for((t=0;t++<RANDOM%6;)){
s+=${m:RANDOM%4:1}
}
printf "$s"
}

Provalo online!

Risposta originale

Bash , 150 byte

Ho fatto pochissimi colpi di golf e ho cercato di migliorare la mia bash, quindi ogni commento è gradito.

for((i=0;i<${#1}-1;i++));do
c=${1:$i:1}
n=${1:$((i+1)):1}
a=($n ${c,} ${c^} ${n,} ${n^})
shuf -e ${a[@]} -n "$(shuf -i 1-5 -n 1)"|xargs printf %s
done

Provalo online!

Il codice è un ciclo semplice attraverso i caratteri che impostano il carattere corrente ce successivo n, quindi creano un array di 4 possibilità, ripetendo una di esse in modo che ci sia esattamente 5. Quindi mescoliamo quell'array e quindi scegliamo n elementi da esso, dove n stesso è casuale tra 1 e 5.

— Giona
fonte
sembra che manchiprintf %s "$c"
— Nahuel Fouilleul il
1
doe donepuò essere sostituito con non documentato {e}
— Nahuel Fouilleul il
— Nahuel Fouilleul il
1
@roblogic che è intelligente. tyvm.
— Giona,
1
La soluzione a 121 byte è un po 'fragile / buggy, ecco una versione più robusta (133 byte) che dovrebbe gestire tutte le ASCII stampabili, tio.run
— roblogic
2

05AB1E , 18 17 byte

ü)vyн5LΩFyD.š«Ω]J

Ispirato dalla risposta Gaia di @Giuseppe .
-1 byte grazie a @Shaggy .

Provalo online 10 volte o verifica tutti i casi di test 10 volte .

Spiegazione:

ü)             # Create all pairs of the (implicit) input
               #  i.e. "Hello" → [["H","e"],["e","l"],["l","l"],["l","o"]]
  v            # Loop over each these pairs `y`:
   yн          #  Push the first character of pair `y`
   5LΩ         #  Get a random integer in the range [1,5]
      F        #  Inner loop that many times:
       y       #   Push pair `y`
        D.š«   #   Duplicate it, swap the cases of the letters, and merge it with `y`
            Ω  #   Then pop and push a random character from this list of four
  ]J           # After both loops: join the entire stack together to a single string
               # (which is output implicitly as result)
— Kevin Cruijssen
fonte
Non conosco 05AB1E ma, invece di INè, potresti salvare qualcosa spingendo il primo personaggio di y?
— Shaggy,
@Shaggy Sì, davvero .. Grazie! Forse dovrei smettere di giocare a golf per oggi, sono un casino, lol ..
— Kevin Cruijssen,
Sei un disastro? ¨vNUy5LΩFy¹X>è«D.š«Ω?
— Magic Octopus Urn
1
@MagicOctopusUrn Anche se un approccio piuttosto originale, temo che non fa il primo punto della sfida ( " uscita il carattere corrente. "), Dal momento che il risultato può iniziare con t, To sper l'ingresso "String"nel programma, mentre dovrebbe iniziare sempre con il S.
— Kevin Cruijssen,
1

Carbone , 27 byte

ＦＬθ«Ｆ∧ι⊕‽⁵‽⭆✂θ⊖ι⊕ι¹⁺↥λ↧λ§θι

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

ＦＬθ«

Passa sopra tutti gli indici della stringa di input.

Ｆ∧ι⊕‽⁵

Ad eccezione del primo indice, scorrere su un numero casuale compreso tra 1 e 5 incluso ...

‽⭆✂θ⊖ι⊕ι¹⁺↥λ↧λ

... estrae i caratteri precedenti e successivi dalla stringa, prendi le versioni maiuscole e minuscole e scegli un carattere casuale dei quattro.

§θι

Stampa il carattere sull'indice corrente.

— Neil
fonte
1

perl 5 ( -p), 77 byte

s/(.)(?=(.))/$x=$1;'$x.=substr"\U$1$2\L$1$2",4*rand,1;'x(1+5*rand)/gee;s/.$//

TIO

— Nahuel Fouilleul
fonte
Puoi salvare 4 byte usando $&invece di $1, e chop+ -linvece dis/.$//
— Dada il
1

Japt -P , 14 byte

äÈ+Zu pv ö5ö Ä

Provalo

äÈ+Zu pv ö5ö Ä     :Implicit input of string
ä                  :Take each consectutive pair of characters
 È                 :Pass them through the following function as Z
  +                :  Append to the first character of the pair
   Zu              :    Uppercase Z
      p            :    Append
       v           :      Lowercase
         ö         :    Get X random characters, where X is
          5ö       :      Random number in the range [0,5)
             Ä     :      Plus 1
                   :Implicitly join and output
— ispido
fonte
1

Python 3 , 167 byte

from random import*;c=choice
def f(s):
 i=0;r=""
 for i in range(len(s)-1):
  r+=s[i]
  for j in range(randrange(5)):r+=c([str.upper,str.lower])(c(s[i:i+2]))
 return r

Provalo online!

— Sara J
fonte
1

Gelatina , 14 byte

;;;Œs$Xɗ¥5X¤¡Ɲ

Provalo online!

Spiegazione

             Ɲ | For each overlapping pair of letters
;              | Join the first letter to...
         5X¤¡  | Between 1 and 5 repetitions of...
      Xɗ¥      | A randomly selected character from...
 ;;Œs$         | A list of the two letters and the swapped case versions of both
— Nick Kennedy
fonte
1

C (GCC) 175 162 byte

-12 byte da LambdaBeta

f(s,S,i,r,a)char*s,*S,*i;{srand(time(0));for(i=S;*(s+1);++s){*i++=*s;for(r=rand()%5+1;r--;*i++=rand()&1?a>96&a<123|a>64&a<91?a^32:a:a)a=rand()&1?*s:*(s+1);}*i=0;}

Provalo online

— rtpax
fonte
Non penso che ti serva 0nella prima riga.
— LambdaBeta,
Inoltre puoi salvare molti caratteri prendendo il buffer Scome parametro e aggiungendo le tue variabili all'elenco degli argomenti: provalo online!
— LambdaBeta,
@LambdaBeta si scopre che hai ragione riguardo a 0, il che non ne valeva la pena avere#define più
— rtpax
— ceilingcat
1

PowerShell , 154 105 103 95 87 byte

-67 byte grazie a mazzy che non possono essere fermati

-join(($x=$args)|%{$_;$x[$i,++$i]*5|%{"$_"|% *wer;"$_"|% *per}|random -c(1..5|random)})

Provalo online!

Non è un metodo fantastico ma funziona. Adesso è abbastanza buono. Accetta input tramite splatting

— Veskah
fonte
Oh, wow, questo è un sacco di byte.
— MilkyWay90
1
@mazzy Dang dog. Devo prendere l'abitudine di accovacciarmi tutto il tempo, ma non sapevo che potevi scambiare i membri dei caratteri jolly in quel modo.
— Veskah,
1
Mi dispiace 87 byte
— mazzy
0

Scala 2.12.8, 214 byte

Versione golfizzata:

val r=scala.util.Random;println(readLine.toList.sliding(2).flatMap{case a :: b :: Nil=>(a +: (0 to r.nextInt(5)).map{_=>((c: Char)=>if(r.nextBoolean)c.toUpper else c.toLower)(if(r.nextBoolean)a else b)})}.mkString)

Giocato a golf con newline e rientri:

val r=scala.util.Random
println(readLine.toList.sliding(2).flatMap{
  case a :: b :: Nil=>
    (a +: (0 to r.nextInt(5)).map{_=>
      ((c: Char)=>if(r.nextBoolean)c.toUpper else c.toLower)(if(r.nextBoolean)a else b)
    })
}.mkString)

Ungolfed:

import scala.io.StdIn
import scala.util.Random

def gobble(input: String): String = {
  input.toList.sliding(2).flatMap {
    case thisChar :: nextChar :: Nil =>
      val numberOfAdditions = Random.nextInt(5)
      (thisChar +: (0 to numberOfAdditions).map { _ =>
        val char = if(Random.nextBoolean) thisChar else nextChar
        val cc = if(Random.nextBoolean) char.toUpper else char.ToLower
        cc
      })
  }.mkString
}

println(gobble(StdIn.readLine()))
— Soren
fonte
1
Non c'è modo di trasformare a :: b :: Nilin a::b::Nil? Lo stesso per a :+, a:+()o a.:+()potrebbe funzionare
— Ven
@Ven a::b::Nilprovoca un errore di compilazione. +:è un metodo definito nell'elenco, quindi potrebbe risparmiare spazio eliminando le parentesi esterne?
— Soren,
Hai solo un elem qui, quindi non è comunque autotupling
— Ven
0

Query T-SQL, 286 byte

DECLARE @ char(999)='String'

SELECT @=stuff(@,n+2,0,s)FROM(SELECT
top 999*,substring(lower(c)+upper(c),abs(v%4)+1,1)s
FROM(SELECT*,number n,substring(@,number+1,2)c,cast(newid()as varbinary)v
FROM(values(1),(2),(3),(4),(5))F(h),spt_values)D
WHERE'P'=type and n<len(@)-1and h>v%3+2ORDER
BY-n)E
PRINT LEFT(@,len(@)-1)

Provalo online purtroppo la versione online mostra sempre lo stesso risultato per lo stesso varchar, a differenza di MS SQL Server Management Studio

— t-clausen.dk
fonte
0

C (gcc) , 110 109 byte

i,p;g(char*_){for(i=rand(putchar(*_))%1024;p=_[i%2],putchar(i&2&&p>64&~-p%32<26?p^32:p),i/=4;);_[2]&&g(_+1);}

Provalo online!

-1 grazie a ceilingcat

i,p;g(char*_){
    for(i=rand(putchar(*_)) //print current char
         %1024;             // and get 10 random bits
        p=_[i%2],           //1st bit => current/next char
        putchar(i&2&&       //2nd bit => toggle case
            p>64&~-p%32<26  // if char-to-print is alphabetic
            ?p^32:p),
        i/=4;);             //discard two bits
    _[2]&&g(_+1);           //if next isn't last char, repeat with next char
}

Il numero di caratteri stampati (per carattere di input) non è uniformemente casuale:

1  if      i<   4 (  4/1024 = 1/256)
2  if   4<=i<  16 ( 12/1024 = 3/256)
3  if  16<=i<  64 ( 48/1024 = 3/ 64)
4  if  64<=i< 256 (192/1024 = 3/ 16)
5  if 256<=i<1024 (768/1024 = 3/  4)
— attinat
fonte
0

Zsh, 113 107 byte

Con molto aiuto da man zshexpne man zshparam.Provalo online!

  • -6 da parte mia, ottimizzando
for ((;i<#1;i++)){m=${1:$i:2};m=$m:l$m:u
for ((;t<RANDOM%5;t++))x+=${m[RANDOM%4]}
echo ${1[i]}$x\\c;t=;x=;}
— roblogic
fonte
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.