Crea un programma per gatti, noto anche come programma che accetta un input e lo stampa.

... Tranne, il programma toglierà casualmente i caratteri dal tuo input e lo stamperà invece.

Ogni personaggio nell'input dovrebbe avere generalmente le stesse probabilità di essere rimosso con il programma, sebbene, dato che è difficile farlo, le probabilità per ciascun personaggio possano variare al massimo del 10%.

Il programma dovrebbe prendere l'input, quindi rimuovere casualmente i caratteri dall'input, quindi stampare di nuovo quella versione. (Puoi stampare con nuove righe finali o altri caratteri nel caso in cui la tua lingua debba stampare nuove righe.)

Se l'input fosse BOOOWL, non dovrebbe rimuovere tutte le O con uguale probabilità: ogni carattere (non unico) dovrebbe essere considerato, quindi invece di ogni O combinata con una possibilità di 1/5 (ad esempio), ogni O dovrebbe avere un 1 / 5 possibilità, quindi, invece di 1/5 possibilità di BWL, dovrebbe esserci 1/5 possibilità di BOWL,BOOWL .

L'input è limitato a STDIN o equivalente più vicino.

Ogni personaggio deve avere un minimo del 10% e un massimo del 30% di probabilità di essere rimosso.

Le probabilità di ogni personaggio devono essere calcolate individualmente.

Puoi usare qualsiasi componente della tua lingua che supporti azioni casuali, sia esso funzioni o qualcos'altro.

L'output deve essere tramite STDOUT o l'equivalente più vicino. Se la tua lingua ha STDOUT, non eseguire l'output in nessun altro modo. Se la tua lingua non può generare stringhe come testo, usa l'equivalente più vicino (qui l'output dell'array di caratteri C è OK).

Questo è il codice golf. Vince il programma più breve.

Japt -f , 2 byte

5ö

Il -fflag "esegue il programma su ciascun elemento nel primo input, generando una matrice di quelli che restituiscono un valore di verità". 5örestituisce un numero casuale compreso tra 0 (incluso) e 5 (esclusivo). Come JavaScript, 0 è errato in Japt.

Provalo

Python 3 , 63 byte

from random import*
for c in input():print(end=c[random()<.2:])

Provalo online!

Python 2 , 67 65 byte

from random import*
print''.join(c for c in input()if.8>random())

Provalo online!

Ogni personaggio ha una probabilità del 20% di essere lasciato cadere.

Approccio diverso, stessa lunghezza:

from random import*
print''.join(c[random()<.2:]for c in input())

Provalo online!

Carbone , 4 byte

ΦＳ‽⁵

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

 Ｓ      Input a string
Φ       Filter where nonzero
  ‽⁵    Random number 0..4
        Implicitly print

È possibile utilizzare qualsiasi numero da 4a 10per ottenere le probabilità di 25%a 10%, rispettivamente.

Befunge-98 (PyFunge) , 11 byte

>#@~3j4???,

Provalo online!

Ogni personaggio ha una probabilità del 25% di essere rimosso. Questa decisione viene presa in base alle tre ?istruzioni.

?imposta il contatore del programma su una delle quattro direzioni, con uguale probabilità. In questo caso, su e giù tornano indietro con la stessa istruzione, quindi possiamo ignorarli come opzioni.

Esistono due modi per uscire dalla foresta di ?s: a destra (output) e a sinistra (nessun output). Questa situazione è simmetrica, per cui se a partire dalla metà ?, c'è un $p_2 = 1/2$ possibilità di emettere. La possibilità di emettere se partendo da destra ?è $p_3 = 1/2 * 1 + 1/2 * p_2 = 3/4$ . Pertanto, dopo aver letto un personaggio, saltiamo all'estrema destra ?per determinare se produrre o meno.

Ottava , 23 byte

Genera una matrice della stessa dimensione dell'input (le stringhe in Octave sono matrici di caratteri), controlla ciascuno dei numeri casuali se è maggiore di 0.2e quindi utilizza l'indicizzazione logica per estrarre i caratteri nelle posizioni corrispondenti.

@(s)s(rand(size(s))>.2)

Provalo online!

Gelatina , 9 5 byte

5X’µƇ

Provalo online!

Una monade che prende come argomento una stringa Jelly e restituisce la stringa Jelly elaborata. Se utilizzato come programma completo, stampa implicitamente l'output. Ogni personaggio ha una probabilità del 20% di essere rimosso.

Spiegazione

   µƇ | Filter using the following as a monad for each character:
5X    | - Random number between 1 and 5
  ’   | - Decreased by 1

Japt , 3 byte

Ogni personaggio ha una probabilità su 5 di essere rimosso. Il 5può essere cambiato in qualsiasi cosa tra 4& 9, incluso o Aper 10cambiare le probabilità.

Æ5ö

Provalo

Æ5ö     :Implicit input of string
Æ       :Filter by
 5ö     :  Random integer in the range [0,5), with 0 being falsey

Wolfram Language (Mathematica) , 24 byte

Select[RandomReal[]>.2&]

Provalo online!

Accetta un elenco di caratteri come input. Ogni personaggio ha la .2possibilità di essere rimosso.

05AB1E , 5 4 byte

ʒ₄Ω≠

-1 byte grazie a @Grimy .

Provalo online o esegui lo stesso programma 10 volte .

Ogni personaggio ha una variazione del 25% di essere lasciato cadere.

Spiegazione:

ʒ     # Filter the characters of the (implicit) input-string by:
 ₄    #  Push 1000
  Ω   #  Pop and push a random digit from it
   ≠  #  And check that it's NOT 1 (!=1)
      # (after which the result is output implicitly)

≠potrebbe anche essere _( ==0).

MATL , 9 byte

t&n&r.2>)

Exaplanation:

t         implicitly take input and duplicate it
 &n       compute the size of the input and...
   &r     generate a random array of that size
     .2>  check which entries of that array are greater than 0.2
        ) and use the result using logical indices to extract certain characters of the input

Provalo online!

Pyth , 8 5 byte

sfO4Q

Provalo online!

sfO4Q   Implicit: Q=eval(input())
 f  Q   Filter characters of Q where the following is truthy:
  O4      Random number in the range [0-4)
          Any non-zero value is truthy, so this will drop characters 25% of the time
s       Concatenate into string, implicit print

Versione precedente, 8 byte:

s*Vm!!O4

Provalo online!

s*Vm!!O4QQ   Implicit: Q=eval(input())
             Trailing QQ inferred
   m    Q    Map each character in Q using:
      O4       Choose random integer in [0-4)
    !!         Logical NOT twice - maps 0 to 0, anything else to 1
             The result is a list of 0s and 1s, with 0 having 25% chance to appear
 *V      Q   Vectorised multiplication of the above with Q
s            Concatenate into string, implicit print

Cubix , 20 byte

u$w\A|UDw@?;...>o._U

Provalo online!

Più a lungo di quanto avessi sperato, dato che avevo un certo numero di operazioni che non riuscivo a liberarmi. La possibilità di rilasciare un personaggio è del 25%. Presumo che vada bene.

    u $
    w \
A | U D w @ ? ;
. . . > o . _ U
    . .
    . .

Guarda correre

Breve spiegazione:

• A|A questo inizializza lo stack, Input all, refl back, Input all (solo un EOI -1)
• ;? pop to di stack, test per EOI (-1).
• _?@ se negativo, rifletti nuovamente nel test e termina con l'arresto
• $Dsalta \nel setter di direzione casuale.
  • dal settatore di direzione, la direzione 3 conduce oall'uscita per poi di nuovo nel loop, uno manca il osuo percorso e va dritto al loop.

APL (dzaima / APL) , 10 9 byte ^SBCS

Funzione prefisso tacito anonimo. Ogni personaggio ha esattamente il 20% di probabilità di essere rimosso.

⊢⌿⍨4≥∘?5¨

Provalo online!

5¨ zero per ogni personaggio

? intervallo intero casuale 1–5 per ogni carattere

4≥ Maschera booleana per quegli interi che sono inferiori o uguali a 4

⊢⌿⍨ filtra l'argomento usando quella maschera

Retina , 15 byte

/./_?(`.

Provalo online! Spiegazione:

/./_

Elabora ogni personaggio singolarmente.

?(`

Effettua una sostituzione a caso. La prima sostituzione cancella il personaggio, mentre gli altri tre lo lasciano invariato, dando così la 25%possibilità di eliminare il personaggio. Questo può essere ridotto se necessario aggiungendo coppie aggiuntive di newline.

R , 32 23 byte

function(x)x[rt(x,3)<1]

Provalo online!

Una funzione che accetta un vettore di carattere come input e restituisce un vettore di carattere elaborato. Ogni personaggio ha una probabilità del 20% di essere rimosso.

Grazie a @Roland e @Giueseppe per aver contribuito a salvare 7 byte e @JDL per altri 2!

T-SQL 2012, 83 byte

Riproduzione ciclica dell'ingresso da destra a sinistra rimuovendo 0 o 1 carattere.

Probabilità del 25% per ogni personaggio rimosso.

DECLARE @i varchar(max)='The cat ate my homework'

DECLARE @ int=len(@i)WHILE @>0SELECT
@i=stuff(@i,@,str(rand()*2)/2,''),@-=1PRINT @i

Spiegazione:

rand()*2 restituisce un float, che non può essere usato in stuff comando.

Lo strconverte in un varchar dopo l'arrotondamento al numero intero più vicino. Il float viene convertito in varchar (che non è consentito come terzo parametro instuff entrambi i casi ).

Questo varchar ha il 25% di probabilità di essere "2", il 50% di probabilità di essere "1", il 25% di probabilità di essere "0". Dividendo per 2, c'è una probabilità del 25% che il risultato sia 1. Questa divisione converte varchar in un numero intero.

Il numero intero è il terzo parametro previsto nella stufffunzione.

Provalo online

J , 10 byte

#~5>6?@$~#

Provalo online!

Simile alla risposta APL di Adam, anche se in realtà l'ho scritta prima di guardare la sua.

• 6.. $~ #Prendi la lunghezza dell'input #e modella $~il numero 6 in un elenco così lungo.
• ?@Tratta ogni sei in quella lista come un dado e lancialo ?.
• >5Il dado è inferiore a 5 (i valori possibili sono 0..5)? Usa quel risultato booleano per creare una maschera di bit.
• #~ Filtra l'input con quella maschera.

Perl 5 -p , 18 byte

s/./.2<rand&&$&/ge

Provalo online!

Ogni personaggio ha una probabilità del 20% di essere lasciato cadere.

Javascript,  46   44  51 byte

i=>alert([...i].filter(c=>Math.random()>.2).join``)

+7 byte a causa del requisito STDOUT aggiunto

-2 byte grazie a Birjolaxew

risposta originale: 44 byte senza il requisito STDOUT

i=>[...i].filter(c=>Math.random()>.2).join``

Scala , 51 46 30 byte

s=>s.flatMap(x=>if(math.random>.2)Some(x)else None)

Provalo online!

PS. Come in molte altre soluzioni, la probabilità di far cadere il carattere è del 20%.

Aggiornare:

-5 byte usando String invece dell'opzione [String] in flatMap

s=>s.flatMap(x=>if(math.random>.2)x+""else "")

30 byte utilizzando il filtro

s=>s.filter(x=>math.random>.2)

C # (compilatore interattivo Visual C #) , 71 byte

var y=new Random();foreach(var k in ReadLine())if(y.Next(5)<4)Write(k);

Provalo online!

PHP , 43 42 byte

for(;''<$l=$argn[$i++];rand()%5&&print$l);

Provalo online!

Ogni personaggio ha il 20% di probabilità di essere rimosso.

C (gcc) , 50 byte

Questo programma ha una probabilità del 20% di lasciare una lettera. Sfortunatamente il generatore di numeri casuali non viene seminato, quindi ottieni la stessa sequenza ad ogni corsa. Fondamentalmente l'unico trucco è invertire il carattere di input per interrompere il loop su EOF.

main(c){for(;c=~getchar();rand()%5&&putchar(~c));}

Provalo online!

C (gcc) , 64 59 byte

Grazie a ceilingcat per i -5 byte.

Se si desidera che l'RNG sia seminato su ogni corsa.

main(c){for(srand(&c);c=~getchar();rand()%5&&putchar(~c));}

Provalo online!

Lua , 69 68 byte

for c in io.lines(nil,1)do io.write(math.random()>.2 and c or '')end

Provalo online!

Un po 'semplice, ma sembra essere la versione più breve: iterare su stdin char con char (con io.lines... quel nome è fuorviante), quindi in base a un valore casuale stampare una o una stringa vuota (es. Niente).

Giava

Non terminante: 82 byte

v->{for(int i;;i=System.in.read(),System.out.print(Math.random()<.2?"":(char)i));}

Terminazione (TIO): 105 byte

v->{var n=System.in;for(int i;n.available()>0;i=n.read(),System.out.print(Math.random()<.2?"":(char)i));}

Zsh , 53 41 byte

_{-12 , grazie a GammaFunction}

41 byte: provalo online!

Converte l'input in una matrice di caratteri, quindi tenta di stampare ogni elemento c, a meno che non venga mangiato dalla ((RANDOM%4))valutazione in falso!

for c (${(s::)1})((RANDOM%4))&&echo $c\\c

53 byte: provalo online!

Un'iterazione più semplice, ma dettagliata, sulla lunghezza della stringa.

for ((;i<$#1;i++)){((RANDOM%4>0))&&echo "${1[i]}\c";}

Zsh , 50 byte

for c (${(s::)"$(<&0)"})
((RANDOM%5))&&echo -nE $c

Provalo online!

Simile alla risposta di RobLogic, ma segue più da vicino i requisiti di input e funziona per input con barre rovesciate.

"$(<&0)"invece "<&0"o $(<&0)perché il primo non funziona nelle sostituzioni e il secondo mangia le nuove righe. I -nEflag sono necessari per impedire che le barre rovesciate vengano analizzate come sequenze di escape e per impedire l'inserimento di nuove righe.

echo -nE

MathGolf , 5 byte

æƒ√∞*

Provalo online!

Spiegazione

æ       foreach character...
 ƒ      random float in range [0,1)
  √     take square root (making P(x < 0.5) = 0.25)
   ∞    pop a, push 2*a
    *   repeat character int(x) times

Ogni personaggio verrà ripetuto 0 o 1 volte, a seconda del valore casuale. Poiché il valore previsto dopo lo spostamento della radice quadrata, esiste una probabilità del 25% che ogni carattere venga rimosso.

Alternativa a 5 byte

gÉ;4w

Filtra i caratteri per un numero casuale in [0, 4]. A causa del funzionamento del filtro, devo scartare il carattere effettivo all'interno del ciclo del filtro, che aggiunge 1 byte.

GFortran , 120 byte

Non male, se usiamo la RAN()funzione deprecata , che è pseudo- casuale, cioè ottieni la stessa sequenza ogni volta. Il modo corretto di generare numeri casuali in GFortran è con CALL RANDOM_SEED()e CALL RANDOM_NUMBER(R)ma è un sacco di byte!

character(99)S;read(*,'(A)')S;do i=1,len_trim(S)
if(ran(0)*5.gt.1)then;write(*,'(A)',advance="no")S(i:i)
endif;enddo;end

Provalo online!

Oracle SQL, 133 byte

select listagg(decode(sign(dbms_random.value-0.2),1,substr(x,level,1)))within group(order by level)from t connect by level<=length(x)

Funziona presupponendo che i dati di input siano memorizzati in una tabella t (x), ad es

with t(x) as (select 'The cat ate my homework' from dual)