猫又吃了你的输入！

30

创建一个cat程序，也就是一个接受输入并打印的程序。

...此外，该程序将随机从输入中删除字符并打印出来。

输入中的每个字符的机率通常应相等，但是很难做到，每个字符的机率最多只能相差10％。

您的程序应采用输入，然后从输入中随机删除字符，然后再次打印该版本。（如果您的语言必须打印换行符，则可以使用尾随换行符或其他字符进行打印。）

如果输入为BOOOWL，则不应以相等的机会删除所有O：应该考虑每个字符（不是唯一的），因此，每个O都应具有1的机会，而不是每个合并的O具有1/5的机会。 / 5的机率，因此，BWL与其应该有1/5的机率，不如应该有1/5的机率BOWL，BOOWL。

输入仅限于STDIN或最接近的等效项。

每个字符必须必须除去最低10％和最大30％的机会的。

每个角色的赔率应单独计算。

您可以使用语言中支持随机动作的任何组件，无论是函数还是其他组件。

输出必须通过STDOUT或最接近的等效输出。如果您的语言确实有STDOUT，请勿以任何其他方式输出。如果您的语言无法将字符串输出为文本，请使用最接近的等效字符串（此处的C的字符数组输出可以）。

这是代码高尔夫。最短的程序获胜。

code-golf  string  random 
— 安德鲁
source
4
是否应该总是有10％到30％的机会删除特定角色？还是仅出于示例目的？
— attinat
2
“一组字符”是什么意思？如果输入是否BOWL OF SOUP可以O一次性删除所有？
— roblogic
1
到目前为止，所有答案都会使用20％的固定机率删除字符。我不确定问题的意图是所有角色的赔率都一样。
— Nzall
3
Output must be through STDOUT, as a text. Do not output a character array.<-我有一种语言，允许您输出字符数组（在输出之前将其展平）。那是不允许的吗？像C这样的语言怎么样，其中的字符串基本上是一个字符数组？
— Ismael Miguel
1
使用最接近的等效项。C的字符数组字符串可以，因为它们与文本最接近。
— 安德鲁

Answers:

10

Japt -f，2个字节

5ö

该-f标志“在第一个输入中的每个元素上运行程序，输出返回真实值的数组。” 5ö返回介于0（含）和5（不含）之间的随机数。像JavaScript一样，Japt中的0是虚假的。

试试吧

— 无知的体现
source
2
我会回到过去，制作一种语言，o面临的挑战是什么，然后回去提交我的答案，或者写出一个空字符串：p
— Andrew
命令行标志不应该计入字节数吗？
— DanielVestøl
1
@DanielVestøl Click on the -f, in the title.
— Ismael Miguel
1
— Jo King
1
was joke but ok
— Andrew
8

Python 3, 63 bytes

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

Try it online!

Python 2, 67 65 bytes

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

Try it online!

Each character has a 20% chance of beeing dropped.

Different approach, same length:

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

Try it online!

— movatica
source
63 bytes in python 2 with a function
— attinat
The rules explicitly state to write a full program: Create a cat program, a.k.a a program that takes an input and prints it.
— movatica
This only reads the first line of input.
— AKX
Problem does not state it had to read multiple lines.
— movatica
8

Charcoal, 4 bytes

ΦＳ‽⁵

Try it online! Link is to verbose version of code. Explanation:

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

You can use any number from 4 to 10 to get chances of 25% to 10% respectively.

— Neil
source
7

Befunge-98 (PyFunge), 11 bytes

>#@~3j4???,

Try it online!

Each character has a 25% chance of being removed. This decision is made at the three ? instructions.

? sets the program counter to one of the four directions, with equal probability. In this case, up & down wrap back around to the same instruction, so we can ignore those as options.

There are two ways out of the forest of ?s: to the right (output) and to the left (no output). This situation is symmetric, so if starting from the middle ?, there is a p2=1/2 chance of outputting. The chance of outputting if starting from the right ? is p3=1/2∗1+1/2∗p2=3/4. Therefore, after reading a character, we jump to the rightmost ? to determine whether or not to output.

— negative seven
source
5

Octave, 23 bytes

Generates an array of the same size as the input (strings in Octave are character arrays), checks each of the random numbers whether it is greater than 0.2 and then uses logical indexing to extract the characters at the corresponding positions.

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

Try it online!

— flawr
source
5

Jelly, 9 5 bytes

5X’µƇ

Try it online!

A monad which takes a Jelly string as its argument and returns the processed Jelly string. When used as a full program implicitly prints the output. Each character has a 20% chance of being removed.

Explanation

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

Japt, 3 bytes

Each character has a 1 in 5 chance of being removed. The 5 can be changed to anything between 4 & 9, inclusive, or A for 10 to change the odds.

Æ5ö

Try it

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

05AB1E, 5 4 bytes

ʒ₄Ω≠

-1 byte thanks to @Grimy.

Try it online or run the same program 10 times.

Each character has a 25% change of being dropped.

Explanation:

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

≠ could also be _ (==0).

— Kevin Cruijssen
source
2
5L can be ₄ for -1 (changes the chance from 20% to 25%, which is still acceptable).
— Grimmy
@Grimy Nice one, thanks! :)
— Kevin Cruijssen
4

MATL, 9 bytes

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

Try it online!

— flawr
source
4

Pyth, 8 5 bytes

sfO4Q

Try it 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

Previous version, 8 bytes:

s*Vm!!O4

Try it 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
— Sok
source
Q will throw an error if the input is not python-esque. Errors for example from [1 or a/b. Q, w and z will only work for single-line input, so the best option would probably be j.z
— ar4093
4

Cubix, 20 bytes

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

Try it online!

Longer than I had hoped as I had a number of no-ops that I can't seem to get rid of. The chance to drop a character is 25%. I assume this is okay.

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

Watch it run

Brief explanation:

  • A|A this initialises the the stack, Input all, reflect back, Input all (just an EOI -1)
  • ;? pop to of stack, test for EOI (-1).
  • _?@ if negative, reflect back into test and end on halt
  • $D jump the \ into the random direction setter.
    • from the direction setter, 3 direction lead to the o for output then back into the loop, one misses the o in it's path and goes straight to the loop.
— MickyT
source
3

APL (dzaima/APL), 10 9 bytesSBCS

Anonymous tacit prefix function. Each character has exactly 20% chance of being removed.

⊢⌿⍨4≥∘?5¨

Try it online!

5¨ zero for each character

? random integer range 1–5 for each character

4≥ Boolean mask for those integers that are less than or equal to 4

⊢⌿⍨ filter the argument using that mask

— Adám
source
3

Retina, 15 bytes

/./_?(`.

Try it online! Explanation:

/./_

Process each character individually.

?(`

Perform a substitution at random. The first substitution deletes the character, while the other three leave it unchanged, thus giving a 25% chance of deleting the character. This can be decreased as necessary by appending additional pairs of newlines.

— Neil
source
3

R, 32 23 bytes

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

Try it online!

A function taking a character vector as input and returning a processed character vector. Each character has a 20% chance of being removed.

Thanks to @Roland and @Giueseppe for helping save 7 bytes, and @JDL for a further 2!

— Nick Kennedy
source
1
function(x)x[!rbinom(x,1,0.2)]
— Roland
along the same lines as @Roland, function(x)x[rf(x,1,1)>1]; df(1,1,1) is about 0.16 which does the trick.
— Giuseppe
or rt(x,3)>1 (about 20% chance)
— JDL
2
@JDL it’s <1, but thanks! Another 2 saved.
— Nick Kennedy
3

T-SQL 2012, 83 bytes

Looping through the input from right to left removing 0 or 1 character.

25% chance for each character getting removed.

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

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

Explanation:

rand()*2 returns a float, which can't be used in the stuff command.

The str converts this into a varchar after rounding to nearest whole number. The float is being converted to a varchar(which isn't allowed as third parameter in stuff either).

This varchar has a 25% chance of being '2', 50% chance of being '1', 25% chance of being '0'. Dividing by 2, there is a 25% chance of result being 1. This division converts the varchar to an integer.

Integer is the expected third parameter in stuff function.

Try it online

— t-clausen.dk
source
Very nice trick with STR, I will have to remember that. Not sure it is fair to piggyback off your (uncounted) DECLARE in your (counted) code; but changing that would only cost you 1 byte, since you can eliminate the extra SET with DECLARE @ INT=len(@i)
— BradC
@BradC I agree, and I will try to remember not to piggyback in the future
— t-clausen.dk
2

J, 10 bytes

#~5>6?@$~#

Try it online!

Similar to Adam's APL answer, though I actually wrote it before looking at his.

  • 6.. $~ # Take the length of input # and shape $~ the number 6 into a list that long.
  • ?@ Treat each six in that list as a die and roll ? it.
  • >5 Is the die less than 5 (possible values are 0..5)? Use that boolean result to create a bit mask.
  • #~ Filter the input with that mask.
— Jonah
source
2

Javascript,  46   44  51 bytes

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

+7 bytes because of the added STDOUT requirement

-2 bytes thank to Birjolaxew

original answer: 44 bytes without the STDOUT requirement

i=>[...i].filter(c=>Math.random()>.2).join``
— jonatjano
source
Since you don't use the name of the function, you're allowed to just provide the function itself. Removing f= gets you down to 44 bytes. You may also input/output as an array, which should save you quite a bit.
— Birjolaxew
@Birjolaxew I'm not sure but as I understand it the question disallow the use of char array if the language has string
— jonatjano
Yes, Andrew edited the question with additional requirements after my comment. This is generally frowned upon because it invalidates answers that were previously valid (in this case it's even debatable whether your initial answer fits the "Output must be through STDOUT" requirement).
— Birjolaxew
What does join`` mean? Can't find it in the spec (cause I don't really know what it is)
— nick zoum
1
@nickzoum in es6 it is equivalent to join("") mdn revelent page
— jonatjano
2

Scala, 51 46 30 bytes

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

Try it online!

PS. Like in many other solutions, the probability of dropping char is 20%.

Update:

-5 bytes by using String instead of Option[String] in flatMap

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

30 bytes by using filter

s=>s.filter(x=>math.random>.2)
— Dr Y Wit
source
1
You can shave off 7 bytes by changing scala.math.random to math.random and 0.2 to .2. Nice trick using ^ like that.
— Kjetil S.
@KjetilS, thank you. I also posted function literals instead of function definitions as a solution. It is acceptable according to this: codegolf.stackexchange.com/questions/3885/…
— Dr Y Wit
2

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

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

Try it online!

— Embodiment of Ignorance
source
I think that < 1 is eating too much. Maybe <3 or < 4 matches the parameters of the problem. Anyway this does not change the length of the code.
— Luca
I haven't programmed in C# in a while, but why is't new Random().Next(5) directly possible?
— Kevin Cruijssen
1
@KevinCruijssen Because then the same seed will be used for each number, so each number be the same. Just try it with new Random().Next(5), all you will get is the whole input or nothing.
— Embodiment of Ignorance
1
@KevinCruijssen when using new Random(), the default seed value is Environment.TickCount, which increments every millisecond. If they're all created in the same millisecond tick, they will all have the same seed. The answer is only using a single instance of Random, and when it's called it updates the internal seed value - so each time Next() is called, it creates a different output value. .Net Core however uses a singleton RNG to generate the seed, so it doesn't have this problem
— Zac Faragher
1
@BenjaminUrquhart Fixed, but added 26 bytes. Also, one can argue doesn't say input has to be from STDIN, but restricted to STDIN or closest equivalent, and function arguments may be the closest equivalent, but I'm not going to do that
— Embodiment of Ignorance
1

C (gcc), 50 bytes

This program has a 20% chance of dropping a letter. Unfortunately the random number generator isn't seeded so you get the same sequence on each run. Basically the only trick is inverting the input character to halt the loop on EOF.

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

Try it online!

C (gcc), 64 59 bytes

Thanks to ceilingcat for the -5 bytes.

If you want the RNG seeded on each run.

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

Try it online!

— ErikF
source
You don't have to use main() for Code Golf submissions, you can also define an arbitrary function that does what is required. So you can write f(c){...}.
— G. Sliepen
1

Lua, 69 68 bytes

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

Try it online!

Kinda straightforward, but seems to be shortest version: iterate over stdin char by char (with io.lines… that name is misleading), then based on random value either print one or empty string (e.g. nothing).

— val says Reinstate Monica
source
1

Java

Non-terminating: 82 bytes

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

Terminating (TIO): 105 bytes

v->{var n=System.in;for(int i;n.available()>0;i=n.read(),System.out.print(Math.random()<.2?"":(char)i));}
— Benjamin Urquhart
source
Is dealing with stdout really necessary? Other answers only create a function just converting a string. Seems unfair towards Java. If this C# solution is valid, then s->s.filter(c->Math.random()<.2) is too.
— Holger
@Holger Input is restricted to STDIN or closest equivalent. and Output must be through STDOUT or the closest equivalent. If your language does have STDOUT, do not output in any other way. So no, that answer is not valid
— Benjamin Urquhart
1

Zsh, 53 41 bytes

-12, thanks to GammaFunction

41 bytes: try it online!

Converts the input to an array of characters, then tries to print each element c, unless it's eaten by the ((RANDOM%4)) evaluating to false!

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

53 bytes: try it online!

A more straightforward, but verbose, iteration over string-length. 

for ((;i<$#1;i++)){((RANDOM%4>0))&&echo "${1[i]}\c";}
— roblogic
source
1
Smart use of \c, I would not have remembered that! There's still a few optimizations to be made...
— GammaFunction
Nice, clever use of RANDOM and array conversion
— roblogic
1

Zsh, 50 bytes

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

Try it online!

Similar to RobLogic's answer, but following the input requirements more closely, and works for inputs with backslashes.

"$(<&0)" instead of "<&0" or $(<&0) because the first doesn't work in substitutions, and the second eats newlines. The -nE flags are necessary to prevent backslashes from being parsed as escape sequences, and to prevent newlines being inserted.

echo -nE

— GammaFunction
source
1

MathGolf, 5 bytes

æƒ√∞*

Try it online!

Explanation

æ       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

Each character will be repeated 0 or 1 times, depending on the random value. Since the expected value after the square root is shifted, there is a 25% probability that each character is removed.

Alternative 5-byter

gÉ;4w

Filter the characters by a random number in [0, 4]. Due to how filtering works, I have to discard the actual character within the filter loop, which adds 1 byte.

— maxb
source
0

GFortran, 120 bytes

Not too bad, if we use the deprecated RAN() function, which is pseudo-random, i.e. you get the same sequence each time. The proper way to generate random numbers in GFortran is with CALL RANDOM_SEED() and CALL RANDOM_NUMBER(R) but that's a lot of bytes!

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

Try it online!

— roblogic
source
1
Pseudo randomness is allowed, if that is the closest way you have to making random actions take hold.
— Andrew
0

Oracle SQL, 133 bytes

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)

It works with an assumption that input data is stored in a table t(x), e.g.

with t(x) as (select 'The cat ate my homework' from dual)
— Dr Y Wit
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.