Créez un programme cat, alias un programme qui prend une entrée et l'imprime.

... Sauf que le programme supprimera au hasard les caractères de votre saisie et l'imprimera à la place.

Chaque caractère dans l'entrée devrait généralement avoir des chances égales à supprimer avec le programme, cependant, comme il est difficile de le faire, les chances pour chaque caractère peuvent varier de 10% au maximum.

Votre programme doit prendre l'entrée, puis supprimer au hasard les caractères de l'entrée, puis imprimer à nouveau cette version. (Vous pouvez imprimer avec des retours à la ligne ou d'autres caractères au cas où votre langue doit imprimer des retours à la ligne.)

Si l'entrée était BOOOWL, elle ne devrait pas supprimer tous les Os avec une chance égale: chaque caractère (non unique) devrait être pris en compte, donc au lieu que chaque O combiné ait une chance 1/5 (par exemple), chaque O devrait avoir un 1 / 5 chance, alors, au lieu d'avoir une chance de 1/5 BWL, il devrait y avoir une chance de 1/5 BOWL, BOOWL.

L'entrée est limitée à STDIN ou à son équivalent le plus proche.

Chaque personnage doit avoir un minimum de 10% et un maximum de 30% de chances d'être supprimé.

Les cotes de chaque personnage doivent être calculées individuellement.

Vous pouvez utiliser n'importe quel composant de votre langage prenant en charge des actions aléatoires, que ce soit des fonctions ou autre chose.

La sortie doit être via STDOUT ou l'équivalent le plus proche. Si votre langue a STDOUT, ne sortez pas autrement. Si votre langue ne peut pas produire de chaînes sous forme de texte, utilisez l'équivalent le plus proche (la sortie du tableau de caractères C est OK ici).

C'est le golf de code. Le programme le plus court gagne.

Japt -f , 2 octets

5ö

Le -fdrapeau "exécute le programme sur chaque élément dans la première entrée, produisant un tableau de ceux qui retournent une valeur véridique." 5örenvoie un nombre aléatoire compris entre 0 (inclus) et 5 (exclusif). Comme JavaScript, 0 est faux dans Japt.

Essayez-le

Python 3 , 63 octets

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

Essayez-le en ligne!

Python 2 , 67 65 octets

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

Essayez-le en ligne!

Chaque personnage a 20% de chances d'être abandonné.

Approche différente, même longueur:

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

Essayez-le en ligne!

Fusain , 4 octets

ΦＳ‽⁵

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

Vous pouvez utiliser n'importe quel nombre de 4à 10pour obtenir des chances de 25%à 10%respectivement.

Befunge-98 (PyFunge) , 11 octets

>#@~3j4???,

Essayez-le en ligne!

Chaque personnage a 25% de chances d'être supprimé. Cette décision est prise aux trois ?instructions.

?définit le compteur de programme dans l'une des quatre directions, avec une probabilité égale. Dans ce cas, vous pouvez revenir en haut et en bas à la même instruction, afin que nous puissions ignorer ces options.

Il existe deux façons de sortir de la forêt de ?s: à droite (sortie) et à gauche (pas de sortie). Cette situation est symétrique, de sorte que si à partir du milieu ?, il y a un $p_2 = 1/2$ de probabilité d'émission en sortie. La possibilité de délivrer en sortie si à partir de la droite ?est $p_3 = 1/2 * 1 + 1/2 * p_2 = 3/4$ . Par conséquent, après avoir lu un caractère, nous sautons à l'extrême droite ?pour déterminer s'il faut ou non sortir.

Octave , 23 octets

Génère un tableau de la même taille que l'entrée (les chaînes dans Octave sont des tableaux de caractères), vérifie chacun des nombres aléatoires s'il est supérieur à 0.2, puis utilise l'indexation logique pour extraire les caractères aux positions correspondantes.

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

Essayez-le en ligne!

Gelée , 9 5 octets

5X’µƇ

Essayez-le en ligne!

Une monade qui prend une chaîne Jelly comme argument et renvoie la chaîne Jelly traitée. Lorsqu'il est utilisé en tant que programme complet, il imprime implicitement la sortie. Chaque personnage a 20% de chances d'être supprimé.

Explication

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

Japt , 3 octets

Chaque personnage a 1 chance sur 5 d'être supprimé. Le 5peut être changé en n'importe quoi entre 4& 9, inclus, ou Apour 10changer les cotes.

Æ5ö

Essayez-le

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

Wolfram Language (Mathematica) , 24 octets

Select[RandomReal[]>.2&]

Essayez-le en ligne!

Prend une liste de caractères en entrée. Chaque personnage a une .2chance d'être supprimé.

05AB1E , 5 4 octets

ʒ₄Ω≠

-1 octet grâce à @Grimy .

Essayez-le en ligne ou exécutez le même programme 10 fois .

Chaque personnage a un changement de 25% d'être abandonné.

Explication:

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

≠pourrait également être _( ==0).

MATL , 9 octets

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

Essayez-le en ligne!

Pyth , 8 5 octets

sfO4Q

Essayez-le en ligne!

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

Version précédente, 8 octets:

s*Vm!!O4

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

Plus longtemps que je ne l'avais espéré, car j'ai eu un certain nombre d'opérations inutiles dont je n'arrive pas à me débarrasser. La chance de laisser tomber un personnage est de 25%. Je suppose que ça va.

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

Regardez-le courir

Brève explication:

• A|A cela initialise la pile, entrez tout, réfléchissez, entrez tout (juste un EOI -1)
• ;? pop to of stack, test pour EOI (-1).
• _?@ s'il est négatif, refléter dans le test et terminer à l'arrêt
• $Dsauter le \dans le setter de direction aléatoire.
  • à partir du setter de direction, 3 direction mènent à la osortie pour ensuite revenir dans la boucle, on manque le ochemin dans son et va directement à la boucle.

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

Fonction de préfixe tacite anonyme. Chaque personnage a exactement 20% de chances d'être supprimé.

⊢⌿⍨4≥∘?5¨

Essayez-le en ligne!

5¨ zéro pour chaque caractère

? plage entière aléatoire 1 à 5 pour chaque caractère

4≥ Masque booléen pour les entiers inférieurs ou égaux à 4

⊢⌿⍨ filtrer l'argument en utilisant ce masque

Rétine , 15 octets

/./_?(`.

Essayez-le en ligne! Explication:

/./_

Traitez chaque personnage individuellement.

?(`

Effectuez une substitution au hasard. La première substitution supprime le caractère, tandis que les trois autres le laissent inchangé, donnant ainsi une 25%chance de supprimer le caractère. Cela peut être diminué si nécessaire en ajoutant des paires de nouvelles lignes supplémentaires.

R , 32 23 octets

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

Essayez-le en ligne!

Fonction prenant un vecteur de caractères en entrée et renvoyant un vecteur de caractères traité. Chaque personnage a 20% de chances d'être supprimé.

Merci à @Roland et @Giueseppe pour avoir aidé à économiser 7 octets, et @JDL pour 2 autres!

T-SQL 2012, 83 octets

Boucle à travers l'entrée de droite à gauche en supprimant 0 ou 1 caractère.

25% de chances que chaque personnage soit supprimé.

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

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

Explication:

rand()*2renvoie un flottant, qui ne peut pas être utilisé dans la stuffcommande.

Le strconvertit en varchar après l'arrondi au nombre entier le plus proche. Le flottant est converti en varchar (ce qui n'est pas autorisé comme troisième paramètre dans les stuffdeux cas).

Ce varchar a 25% de chances d'être «2», 50% de chances d'être «1», 25% de chances d'être «0». En divisant par 2, il y a 25% de chances que le résultat soit 1. Cette division convertit le varchar en un entier.

L'entier est le troisième paramètre attendu de la stufffonction.

Essayez-le en ligne

J , 10 octets

#~5>6?@$~#

Essayez-le en ligne!

Semblable à la réponse APL d'Adam, bien que je l'ai écrite avant de regarder la sienne.

• 6.. $~ #Prenez la longueur de l'entrée #et formez $~le nombre 6 dans une liste aussi longue.
• ?@Traitez chacun des six de cette liste comme un dé et lancez- ?le.
• >5Le dé est-il inférieur à 5 (les valeurs possibles sont 0..5)? Utilisez ce résultat booléen pour créer un masque de bits.
• #~ Filtrez l'entrée avec ce masque.

Perl 5 -p , 18 octets

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

Essayez-le en ligne!

Chaque personnage a 20% de chances d'être abandonné.

Javascript,  46   44  51 octets

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

+7 octets en raison de l'exigence STDOUT ajoutée

-2 octets merci à Birjolaxew

réponse d'origine: 44 octets sans l'exigence STDOUT

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

Scala , 51 46 30 octets

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

Essayez-le en ligne!

PS. Comme dans beaucoup d'autres solutions, la probabilité de laisser tomber l'omble est de 20%.

Mise à jour:

-5 octets en utilisant String au lieu de Option [String] dans flatMap

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

30 octets en utilisant un filtre

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

C # (Visual C # Interactive Compiler) , 71 octets

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

Essayez-le en ligne!

PHP , 43 42 octets

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

Essayez-le en ligne!

Chaque personnage a 20% de chances d'être supprimé.

C (gcc) , 50 octets

Ce programme a 20% de chances de laisser tomber une lettre. Malheureusement, le générateur de nombres aléatoires n'est pas amorcé, vous obtenez donc la même séquence à chaque exécution. Fondamentalement, la seule astuce consiste à inverser le caractère d'entrée pour arrêter la boucle sur EOF.

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

Essayez-le en ligne!

C (gcc) , 64 59 octets

Merci à plafondcat pour les -5 octets.

Si vous voulez que le RNG soit ensemencé à chaque exécution.

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

Essayez-le en ligne!

Lua , 69 68 octets

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

Essayez-le en ligne!

Un peu simple, mais semble être la version la plus courte: itérer sur stdin char par char (avec io.lines… ce nom est trompeur), puis en fonction d'une valeur aléatoire, imprimer une chaîne ou une chaîne vide (par exemple rien).

Java

Sans fin: 82 octets

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

Terminaison (TIO): 105 octets

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 octets

_{-12 , grâce à GammaFunction}

41 octets: essayez-le en ligne!

Convertit l'entrée en un tableau de caractères, puis essaie d'imprimer chaque élément c, à moins qu'il ne soit mangé par l' ((RANDOM%4))évaluation en faux!

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

53 octets: essayez-le en ligne!

Une itération plus simple, mais verbeuse, sur la longueur de la chaîne.

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

Zsh , 50 octets

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

Essayez-le en ligne!

Similaire à la réponse de RobLogic, mais en suivant de plus près les exigences d'entrée, et fonctionne pour les entrées avec des barres obliques inverses.

"$(<&0)"au lieu de "<&0"ou $(<&0)parce que le premier ne fonctionne pas en substitutions, et le second mange des sauts de ligne. Les -nEindicateurs sont nécessaires pour empêcher l'analyse des barres obliques inverses en tant que séquences d'échappement et pour empêcher l'insertion de nouvelles lignes.

echo -nE

MathGolf , 5 octets

æƒ√∞*

Essayez-le en ligne!

Explication

æ       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

Chaque caractère sera répété 0 ou 1 fois, selon la valeur aléatoire. Étant donné que la valeur attendue après le déplacement de la racine carrée, il y a une probabilité de 25% que chaque caractère soit supprimé.

Alternative à 5 octets

gÉ;4w

Filtrez les caractères par un nombre aléatoire dans [0, 4]. En raison de la façon dont le filtrage fonctionne, je dois éliminer le caractère réel dans la boucle de filtrage, ce qui ajoute 1 octet.

GFortran , 120 octets

Pas trop mal, si nous utilisons la RAN()fonction obsolète , qui est pseudo- aléatoire, c'est-à-dire que vous obtenez la même séquence à chaque fois. La bonne façon de générer des nombres aléatoires dans GFortran est avec CALL RANDOM_SEED()et CALL RANDOM_NUMBER(R)mais c'est beaucoup d'octets!

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

Essayez-le en ligne!

Oracle SQL, 133 octets

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)

Il fonctionne avec l'hypothèse que les données d'entrée sont stockées dans une table t (x), par exemple

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