List of my CGCC posts as user100411

217589 218686 220776 220800 220804 220806 220807 220808 220823 220892 220894 220898 220899 220901 220903 220906 220909 220950 220975 220987 221023 221033 221051 221057 221061 221062 221064 221067 221115 221119 221221 221228 221233 221240 221245 221388 221392 221399 221403 221412 222441 222443 222444 222573 222574 222582 222675 222770 222945 223076 223081 223086 223091 223095 223098 223257 223302 223647 223653 223695 223709 223789 224337 225044 225045 225051 225054 225058 225059 225104 225107 225108 225118 225122 225160 225165 225238 225275 225276 226297 226303 226530 226745 226747 226751 226752 226798 226799 226838 226898 228910 229544 229550 229552 229556 229557 229713 229721 229739 229742 229959 229961 229963 229964 230204 230293 230328 230354 230362 230439 230533 230905 231143 231156 231172 231255 231532 231538 231566 231571 231692 231696 231697 232985 233000 233001 233018 233029 233077 233088 233197 233227 233237 233358 233361 233556 233611 233636 235246 235247 235249 235408 235419 235421 235422 235423 235424 235428 235458 235465 235469 235471 235472 235573 235638 235659 235660 235672 235683 235685 235689 235691 235785 235834 235904 235905 235906 235907 235909 235934 236048 236049 236184 236461 236614 236615 236678 237156 237157 237158 237161 237164 237165 237273 237274 237315 237320 237349 237351 237488 237526 237598

217589

Pxem, 15 bytes (filename) + 0 byte (contents) = 15 bytes

Filename

Hello, World!.p

Content

(none)

Description of program

The program above should output the phrase without LF. If you'd like LF, here is an alternative filename (19 bytes);

ak.-Hello, World!.p

Description of language

The main feature of this programming language to recognize filename as main routine of the program; content of the file is subroutine.

Implementations

So far there are two major implementations:

218686

Pxem (Filename: 5 bytes; Contents: 0 byte)

Explaination

220776

Pxem, Contents: 0 bytes + Filename: 33 25 bytes

Try it online!

Usage

Give an integer from STDIN. The result is output from stdout, with no LF termination.

How it works

XX.z
# Prepare character 1 at this point
.aXX1.z
# integer input is pushed
.a._XX.z
# duplicate, and is it non-zero?
.a.c.wXX.z
  # then come here
  # also \001.r is an idiom to push zero:
  # actually "n=pop;push(int(random()*n))"
  # where 0<=random()<1
  # because filename cannot have null character
  # don't be afraid of such binary for code golf
  .a\001.rXX.z
  # is input less than zero?
  # DOT-y to DOT-a is:
  # while size<2 OR pop>pop; do something; done
  .a.yXX.z
    # if so, push hyphen so string "-1" is made
    .aXXXX-.z
  .a.aXX.z
  # at this point DOT-y popped two items: zero and input integer
  # so no worry about garbages
  # print the string and exit
  # .p is actually: while !empty; do printf "%c", pop; done
  .a.p.dXX.z
# if input is zero, come here
# .n is printf "%d", pop
# OBTW the "1" will on stack, but it's not matter,
# because it is ignored when program ends
.a.a.n

Previously

220800

Pxem, 10 bytes of file name + 0 bytes of content = 10 bytes

What a low effort.

220804

Pxem, Filename: 4 bytes + Content: 0 bytes = 4 bytes.

220806

Pxem, 5 characters (assumes arbitrary length of filename and arbitrary size of stack are available).

.acvz

How it works

According to this archive of blog, this is how to emulate a CTS:

3.2.2.1. Syntax in EBNF

    Filename = init, main [, omitable ];
    init = dummy, data-string;
    dummy = '01';
    data-string = { data-bit }, end-of-string;
    data-bit = '0', actual-bit;
    actual-bit = '0' | '1';
    end-of-string = '1';
    main = '.z', { command, } exiter, '.a';
    command = empty-checker, actual-command;
    empty-checker = 'c0.z1.z.a.v1.v.c0.z0000.a'; If empty, data string is updated with a '0' string.
    actual-command = '00.a1.z.a0.zv', pushing-data-string-reversed, '.v00.a';
    pushing-data-string-reversed = { actual-bit, '0' };
    exiter = '.c0.z1.z.a.v1.v00.a.c1';
    omitable = '.d.pxe';

But these modification would make it still Turing-complete:

This is thus the code to emulate the program (011, 10, 101) with input "1":

azazz.z.ca.zz.z.a.vz.v.ca.zaaaa.aaa.az.z.aa.zvzazaaa.vaa.a.ca.zz.z.a.vz.v.ca.zaaaa.aaa.az.z.aa.z.vaaza.vaa.a.ca.zz.z.a.vz.v.ca.zaaaa.aaa.az.z.aa.z.vzaaaza.vaa.a.ca.zz.z.a.vz.vaa.a.cz.a

220807

Pxem, Filename: 23 17 bytes + Content: 0 bytes = 23 17 bytes, depends on ASCII-compatible encoding.

Commented

d.t  # heap = 100
.w # loop
  .m.r # push(random(min=0,max=heap-1))
  .c # dup()
  .n # printf("%d",pop())
  ,.o # putchar(',')
.a # break if pop()==0

220808

Dash (POSIX shell with POSIX utility ), 50 47 27 bytes

$((1${1%0*}-1$1?9-9$1%9:0))

Try it online!

The code above evaluates to a string of digit.

Alternative

$((1${1#*0}-1$1?9-9$1%9:0))

How it works

220823

Pxem, Filename: 103 bytes + Content: 0 bytes = 103 bytes

Filename as follows (if your filesystem doesn't support LF, I'm sorry) (also requires to be ASCII-compatible):

x
.p
x.n
.o.n
.o04x
.-.t.z
.c.zxxx
.a.m.m.w
.sx.oab.-
.s.-.c.a.s
.c.o.c.$.mx
.s.s.+.tao.-
.s.m.a.dxxxxx

Content is empty.

Try it online, with rpxem!

Output

x
10
120
xxxx
xxxxx
xxxxxx
xxxxxxx
xxxxxxxx
xxxxxxxxx
xxxxxxxxxx
xxxxxxxxxxx
xxxxxxxxxxxx
xxxxxxxxxxxxx

With comments

Note that every LF is replaced with '?'.

x?.pXX.z # print'x', LF
.a?x.nXX.z # print LF.ord # two-digits
.a?.oXX.z # print LF
.a.n?.sXX.z
.a04x?.-.tXX.z # i = 4
.a.zXX.z # loop
  .a?.c.zxxx?.aXX.z # essentially nop
  .a.m.m.wXX.z # j = i; while j!=0
    .a?.sx.oXX.z # print'x'
    .aab.-?.s.-.cXX.z # j--
  .a.a.s?.c.oXX.z # end-while; print LF
  .a.c.$.mx?.s.s.+.tXX.z # i++
  .aao.-?.s.mXX.z # break if !(14>i)
.a.a.dxxxxx # end-loop; end program

220892

Pxem, (See below)

Depends on invokation

pxemi.7z, 0 bytes (on invokation).

Compile the source code in C++ and run the interpreter with no arguments, like this: /path/to/pxemi. The following line is output to stderr: usage: pxemi pxemFileName.

RPxem, 0 bytes (on invokation)

Just like nk.'s pxemi, run with no arguments: Usage: rpxem path-to-pxem-file.pxe can be seen.

Programs

Pxem, 6 bytes of filename only, case-insensitive, boring.

Pxem, 18 bytes of filename only, case-sensitive output, depends on ASCII-compatible filesystem.

How it works

On every ??.+ each character is generated with sum of two characters' ASCII code from backwards.

220894

Pxem, 11 bytes.

Try it online!

220898

Dash, 26 bytes

cut -c7-|grep ^\ |cut -c2-

Try it online!


Dash, 29 bytes

cut -c7-|grep -vF \*|cut -c2-

Try it online!

OBTW it's POSIX-compatible, if I remember the specs correctly.

220899

sed, 11 bytes + 3 bytes option -nr = 14 bytes.

s/^.{6} //p

Try it online!

sed, 16 bytes

#n
s/^.\{6\} //p

Try it online!

#n on top of line is for -n, which is GNU-extension POSIX-compatible.

220901

Pxem, 88 bytes (filename) + 0 bytes (content) = 88 bytes, with non-printable characters.

Try it online!

Usage

/path/to/pxem/interpreter THAT_PROGRAM_AS_IN_ABOVE <input.txt

COBOL program to be input must be fed from stdin, with LF-styled newlines, whose last line is terminated with LF.

Alternative: Pxem, 100 bytes (filename) + 0 bytes (content) = 100 bytes, printables and LF only.

Filename is as follows:

ab.-.t.i.m.+.w.i.s.i.s.i.s.i.s.i.s.i*.zAB.z.i.c.o
.a02.-.tXX.a.mac.-.zAB.i
.z.i
.aXX.aab.-.t.i.m.+.a

Commented version

XX.z (this is just to format well
.a<0x01>.tXX.z (reg=1
.a.i.m.+.wXX.z (while getchar()!=EOF; do (obtw EOF is -1
   .a.i.s.i.s.i.s.i.s.i.sXX.z (5.times { getchar(); }
   .a.i*.zXX.z (while getchar()!='*'; do
      .aAB.z.i.c.o<0x0A>.aXX.z (do print(c=getchar()) while c!=newline
      .a<0x02>.tXX.z (reg=2
   .aXX.aXX.z ( break; done
   .a.m<0x02>.zXX.z (while reg!=2; do
      .aAB.i<0x0A>.z.i<0x0A>.aXX.z (do c=getchar() while c!=newline
   .aXX.aXX.z ( break; done
   .a<0x01>.tXX.z (reg=1
.a.i.m.+.aXX.z (done
.a

220903

M4, 115 bytes

Also TIL that ifelse can have more than four arguments.

define(f,`ifelse($1,101,,`ifelse(eval($1%15),0,fizzbuzz,eval($1%5),0,buzz,eval($1%3),0,fizz,$1)
f(incr($1))')')f(1)

Try it online!


M4, 143 bytes, SUSv2-compatible.

define(f,`ifelse(`$1',101,,`g(`$1',ifelse(eval($1%3),0,fizz)`'ifelse(eval($1%5),0,buzz))
f(incr($1))')')define(g,`ifelse(len($2),0,$1,$2)')f(1)

Try it online!

I am not familiar with M4, but I tried some bests. What quotations can be removed?

With comments

dnl def f(n): return "" if n==101 else g(n,("fizz" if n%3==0 else "")+("buzz" if n%5==0 else "")+"\n"+f(n+1))
define(f,`ifelse(`$1',101,`',`g(`$1',ifelse(eval($1%3),0,fizz)`'ifelse(eval($1%5),0,buzz))
f(incr($1))')')dnl
dnl def g(n,s): return n if len(s)==0 else n
define(g,`ifelse(len($2),0,$1,$2)')dnl
f(1)

220906

Dash, with these restrictions

Dash, 103 bytes, 5 utilities.

echo ,,fizz,,buzz,fizz,,,fizz,buzz,,fizz,,,fizzbuzz|sed -n ':x
p
bx'|tr , \\n|sed '/./b
=
d'|head -n100

Try it online!

Dash, 124 121 bytes, 9 utilities.

echo xx|sed -n ':x
p
bx'|sed s/\$/fizz/|tr x \\n|paste - - - - -|sed s/\$/buzz/|tr \\t \\n|sed -n '/./p
/^$/='|head -n100

Try it online!

Dash, 133 132 bytes, 10 utilities.

echo|sed -n ':x
p
bx'|paste - - -|sed s/\$/fizz/|tr \\t \\n|paste - - - - -|sed s/\$/buzz/|tr \\t \\n|sed -n '/./p
/^$/='|head -n100

Try it online!

Originally, on GitHub Gist

With comments

echo | sed -n '
    :x
    p
    bx
' | # yes ''
paste - - - | sed s/\$/fizz/ | tr \\t \\n | # if NR%3==0; then $0="fizz";
paste - - - - - | sed s/\$/buzz/ | tr \\t \\n | # if NR%5==0; then $0=$0 "buzz";
sed -n '
    /./p
    /^$/=' | # = is to output line number
head -n 100

220909

Pxem, 9 bytes (filename) + 0 bytes (content) = 9 bytes.

The code is equivalent to:

push 'B'
push 'B'
push 'C'
push(abs(pop()-pop())) if size>=2 else nop
push(abs(pop()-pop())) if size>=2 else nop
printf("%c",pop()) if size>=1 else nop

220950

Pxem, Filename: 96 81 bytes + Content: 0 bytes = 96 81 bytes.

Thanks, Neil, for providing a workaround for -15 bytes!

Try it online! (with pxem.posixism)

With comments

XX.z
.a\020.zXX.z # push 16; while :; do
  .a.tXX.z # heap = pop!
  .a.m\005.%\001.yXXbuzz.aXX.z # while 1>heap%5; do push "buzz"; break; done
  .a.m\003.%\001.yXXfizz.aXX.z # while 1>heap%3; do push "fizz"; break; done
  .a.c.c.z.m\017.-.nXX@.aXX.z # if empty?; then print(heap-15); push "@"; fi
    # this is how while empty?; do something; done works:
    # ".c.c.z bla bla bla .a"
    # NOTE: Fail on pxemi dot 7z and RPxem
    # They need some patches before installing
    # Implementation needs to be document-compliant
    # PS. RPxem v0.0.7 fixed dotC 
  .a.c@.z.pXX.aXX.z # if top!="@"; then print pop all!; fi
  .a.sXX.z # pop!
  .a\n.oXX.z # print "\n"
  .a.m\001.+XX.z # push heap; add one to it
.a.ct.aXX.z # break if equal to 116
.a

Note

Old version

1

220975

#n at first to imply -n

The "#" and the remainder of the line are ignored (treated as a comment), with the single exception that if the first two characters in the file are #n, the default output is suppressed; this is the equivalent of specifying -n on the command line.

Source: sed (from SUSv2)

This is useful if you prefer NOT to output something by default.

...But is it really useful? -n adds either 1 or 2 bytes but #n and LF adds 3.

220987

Pxem, 17 bytes (filename) + 0 bytes (content) = 17 bytes.

Try it online!

With comments

XX.z
.a~.zXX.z # push 127; while size<2 || (pop!=pop); do
  .a.cXX.z # dup
  .a\001.-XX.z # push 1; push abs(pop-pop) iff size>=2
  .a.cXX.z # dup
.a\037.aXX.z # push 31; done
.a.s.pXX.z # pop (* to remove 31 *); while size>0; do printf "%c", pop; done
.a

221023

Dash, 27 24 bytes

$(($1-$2&&$2-$3&&$3-$1))

Try it online!

Sorry for a boring answer; at first if bashism would work, but I could not get out of POSIXism.

The code above evaluates to a string of either 0 or 1.

221033

Pxem, Filename: 39 bytes + Content: 0 bytes = 39 bytes.

How would you do that by control flowing although we don't have negative constants nor the way to obtain negative value without .i or ._!

221051

Pxem, Filename: 28 bytes + Content: 0 bytes = 28 bytes.

Try it online! (with pxem.posixism)

With comments

XX.z
# for three times; do push( read integer); done
.a._._._XX.z
# call subroutine
## NOTE. When DOT-e is performed when stack is a,b,c,bottom,
## then subroutine begins with same content of stack
## And when subroutine ends when stack is d,e,f,bottom,
## then previous stack would be d,e,f,a,b,c,bottom
## to continue origimal procedure
## In this program content is empty, so is subroutine
## thus x,y,z,bottom to x,y,z,x,y,z,bottom,
## which duplicates entire stack
.a.eXX.z
# while size < 2 && pop != pop; do
.a.zXX.z
  # dup; dup; while size<2 && pop!=pop; do
  ## this is equal to while stack is empty; do
  .a.c.c.zXX.z
    # push '1'; putc pop; exit
    .a1.o.dXX.z
  # done
  .a.aXX.z
# done
.a.aXX.z
# push '0'; putc pop; (implicity) exit
.a0.oXX.z
.a

221057

Pxem, 30 bytes (Filename) + 0 bytes (Content) - 25 bytes (bonus) = 5 bytes, requires nonprintable character, does not deal with default.

Try it online! (with pxem.posixism)

With comments

XX.z
# read integer and push it (pxem.posixism errors when not given)
.a._XX.z
# dup; while pop!=0; do
.a.c.wXX.z
  # heap=pop
  .a.tXX.z
  # .e command actually stands for calling content as
  # subroutine BUT content is empty so it stands for
  # duplicating entire stack
  # also non-command substrings stand for literals
  # so stack would have (3*2+1)*2+1*2=30 X's
  .aXXX.eX.eX.eXX.z
  # pop all to output each of them
  .a.pXX.z
  # push heap; push 1; push abs(pop-pop); dup
  .a.m\001.-.cXX.z
# done
.a.a

Pxem, 12 bytes (Filename) + 0 bytes (Content) = 12 bytes.

It outputs 24 X's without trailing LF.

Try it online!

How it works

XX.z
# push two X's
.aXXXX.z
# call content (as subroutine), pushing final result
## NOTE if original stack was 1,2,3 from top,
## the subroutine stack is also intialized with 1,2,3
## Then when returning from subroutine with final result of stack 4,5,6
## then original stack would be 4,5,6,1,2,3
## Since content is empty, it stands for duplicatinf entire stack
.a.eXX.z
## now X,X,X,X
# push two X's
.aXXXX.z
## now four X's
# duplicate entire stack twice
.a.e.eXX.z
# finally pop all to output each of them
.a.p

221061

Dash, 23 bytes

$((-$4)) $2 $3 $((-$1))

Try it online!

Usage

Requires positional parameters for each of A, B, C, and D. Before evaluating the command. Also the code evaluates to just four strings, so run echo command with those code (may not portable when D is originally positive, as hyphen-parameter may be treated as an option).

How it works


Polyglot for Bash, OSH, bosh, Dash, ksh, yash, and Zsh, 25 bytes

$((- $4)) $2 $3 $((- $1))

Try it online!

Differences


Polyglots for Bash and OSH, 19 bytes

Thanks, 2x-1!

$[-$4] $2 $3 $[-$1]

Try it online!

What the heck

$[ ... ] is historically equivalent to $(( ... )), which is not adopted for POSIX.

OBTW adding a space betwee hyphen and dollar (which is +2 bytes), the code would be polyglot for Zsh, too.

221062

Pxem, 21 20 bytes (filename) + 0 bytes (content) = 23 21 20 bytes, requires unprintable character.

Try it online!

With comments

XX.z
# push 1; push int(rand()*pop)
## NOTE rand() outputs 0<=n<1
## NOTE assuming NUL cannot be used for filename
.a\001.rXX.z
# while size<2 || pop!=pop; do
.a.zXX.z
  # dup; print pop; push comma; putc pop
  .a.c.n,.oXX.z
  # push 1; push pop+pop; dup; push 101
  .a\001.+.ce
# done
.a.a

Pxem, 3 bytes (filename) + 20 bytes (content) = 23 bytes, requires unprintable character.

With comment

e.eXX.z # push 101; call content
.a
XX.z
# dup; while pop!=0; do
.a.c.wXX.z
  # push 1; push abs(pop-pop); call content (* result of final stack will be pushed to original *)
  .a\001.-.eXX.z
  # push pop+pop; print pop; push space; print pop; return
  .a.+.n .o.dXX.z
# done; (* implicit return *)
.a.a

Try it online! (with pxem.posixism)

221064

Pxem, 1000010000.

Try it online!

221067

Pxem, filename: 22 bytes + content: 4 bytes - bonus: 10 bytes = 16 bytes.

Try it online!

With comments

XX.z
# while size==0 || pop!=0; do
.a.wXX.z
  # push getchar; dup; push 1; push pop+pop;
  # NOTE EOF is -1
  .a.i.c\001.+XX.z
# done
.a.aXX.z
# push 11; push pop+pop;
.a\013.+XX.z
# push whatever not zero; while pop!=0; do call content; push whatever not zero; done
.al.w.el.a
XX.z
# get called, with my stack initialized to original one
# reverse; pop all to putchar for each of them
# implicitly return, pushing each content of
# my stack from bottom to pop to original one
.a.v.p

Pxem, filename: 14 bytes + content: 0 bytes = 14 bytes.

Wow, shorter than above!

Try it online!

221115

sed, 227 bytes

s/^.o*/<&>/
:a
s/>z\(.o*\)/><\1>/
ta
:b
s/z>/0>/g
y/z/-/
s/oooooooooo/x/g
s/ooooooooo/m9/g
s/oooooooo/m8/g
s/ooooooo/m7/g
s/oooooo/m6/g
s/ooooo/m5/g
s/oooo/m4/g
s/ooo/m3/g
s/oo/m2/g
s/o/m1/g
s/x\([^xm]\)/x0\1/g
s/m//g
y/x/o/
tb

Try it online!

Usage

0 and 1 for input are replaced with z and o respectively. Input is given from stdin, on every line.

With comments

# first integer
s/^.o*/<&>/
# find each item
:a
s/>z\(.o*\)/><\1>/
ta
# below: to decimal
:b
# to zero
s/z>/0>/g
# minus sign
y/z/-/
# to decimal others
# m letter indicates that converting a digit is done
s/oooooooooo/x/g
s/ooooooooo/m9/g
s/oooooooo/m8/g
s/ooooooo/m7/g
s/oooooo/m6/g
s/ooooo/m5/g
s/oooo/m4/g
s/ooo/m3/g
s/oo/m2/g
s/o/m1/g
# not converted yet? then to 0
s/x\([^xm]\)/x0\1/g
s/m//g
y/x/o/
# repeat until every unary is converted
tb

221119

Pxem, Filename: 28 bytes + Content: 0 bytes = 28 bytes.

Try it online! (with pxem.posixism)

With comments

XX.z
# push 9; heap=pop
.a\011.tXX.z
# while empty || pop!=0; do
.a.wXX.z
  # push 48; push getchar
  .a0.iXX.z
  # push abs(pop-pop); if size>=2; then push pop+pop; fi
  .a.-.+XX.z
  # push heap; push 1; push abs(pop-pop)
  .a.m\001.-XX.z
  # dup; heap=pop
  .a.c.tXX.z
# done
.a.aXX.z
# push 48; push abs(pop-pop); printf "%d", pop
.a\055.-.n

221221

Pxem, filename: 2 bytes + content: 64 bytes = 66 bytes.

Thank you for commenting me that I need to use content of the file.

Filename

.e

Content

Stack Exchange Cha.p.c.c.zt - The Nineteenth Byte.p.d.a.v.st.v.p

How it works

Links to TIO

221228

Pxem, filename: 6 bytes + content: 0 bytes = 6 bytes.

Try it online!

.p is until empty; do putchar pop; done. .1 is not a command; treated as a substring for literal.

221233

M4, 10 bytes, with warning

1dnl lnd1-

Try it online!


M4, 16 bytes, clean output

1m4exit tixe4m1-

Try it online!

221240

Pxem, Filename: 32 bytes + Content: 4 bytes = 36 bytes, depends on ASCII-compatible.

Try it online!

How it works

221245

Pxem, Filename: 45 bytes + Content: 0 bytes - Bonus: 30 bytes = 15 bytes.

What it does

Try it online!


Pxem, Filename: 55 bytes + Content: 0 bytes - Bonus: 50 bytes = 5 bytes.

What it does

Try it online!

221388

Pxem, 13 bytes (filename) + 0 bytes (content) = 13 bytes.

With comments

XX.z
.a.wXX.z # while empty || pop!=0; do
  .a.oXX.z # if !empty; then putchar pop; fi
  .a.iXX.z # push getchar (* NOTE EOF IS -1 *)
  .a.c\001.+XX.x # dup; push 1; push pop+pop
.a.aXX.z # done
.a

Try it online!

221392

Pxem, Filename: 30 27 bytes + Content: 0 bytes = 30 27 bytes, does not support signed zero, not clean.

Try it online!

!enilno ti yrT

With comments

Original

XX.z
.a._.nXX.z # push getint; putint pop
.a.o.-XX.z # DOTo and DOT- works like EOF for insufficient items
.aa.dXX.z # push ascii code of a; exit
.a.n.-.-.00y.\001c._.XX.z # deadcode
  ## NOTE this is syntaxically valid
.a

Reversed

XX.z
.a._.cXX.z # push getint; dup
.a\001.yXX.z # push 1; while pop>pop; do
  .a00.-.-XX.z # (*essentially*) push abs(0-pop)
    # NOTE actually: push 48; push 48; 
    #     push abs(pop-pop); push abs(pop-pop)
    # NOTE NULL char not supported for filename
  .a.n.dXX.z # putint pop; exit
.a.aXX.z # done
.a-.o.nXX.z # push hyphen; putchar pop; putint pop
.a._XX.z # this is why it aborts when only an integer is given
.a..c.sXX.z # push dot
.a

Pxem, Filename: 34 bytes + Content: 0 bytes = 34 bytes, clean.

This version deals with exiting; reversed version exits well against non-negative input, too.

Try it online!

221399

Pxem Pxem (esolang-box notation), 162 113 109 bytes.

Eventually as in meta discussion I had to change the language. The following program equals to filename with same name and empty content in original notation.

Be!?BzBc!!B+BzXXFBaBcFBzBsXXFBBaBsBtBvBmBvBcAcB-BaBsBp".e!?.z.c!!.+.zXXF.a.cF.z.sXXF..a.s.t.v.m.v.cAc.-.a.s.p

Try it online!

With comments

XX.z
# represents programs from first .m
# every dot has to be replaced with B, for example,
# because dots are syntaxically special
# append " to it
.aXX(long)".z
# essentially double entire stack
.a.eXX.z
# loop begin
.a!?.zXX.z
  # move every character to bottom
  # HOWEVER B is replaced with DOT
  # when exiting from loop, the stack will be:
  # "(original data)"(modified data)
  #
  # push dummy F if B is not top
  .a.c!!.+.zXXF.aXX.z
  # replace B with dot, and push F if F is not top
  .a.cF.z.sXXF..aXX.z
  # remove dummy
  .a.sXX.z
  # move to bottom
  .a.t.v.m.vXX.z
# get out if "
.a.cAc.-.aXX.z
# finally; discard top
.a.s.p

Previous version

221403

Pxem (pxemi.2.min.posixism), Filename: 14 bytes + Content: 0 bytes = 14 bytes.

Try it online!

221412

Pxem, 29 bytes (Filename) + 0 bytes (Content) = 29 bytes, syntaxically not valid.

How it works

Original

As in this, except with .d: exiting/returning command. Since pxemi.2.min.posixism automatically removes deadcode, the code after that will be ignored, even .a comes before .w (which is syntax error).

Reversed

Since Pxem is stack-oriented, not outputting any characters until EOF would produce input reversed. Then .p outputs from top to bottom, which is in reverse order compared from original input.

TIO links


Pxem, 39 bytes (Filename) + 0 bytes (Content) = 39 bytes, syntaxically safe.

222441

Pxem, 0 bytes (content) + 41 36 bytes (filename).

Inspired by @MD FX.

What it does

Try it online!

Previously

41 bytes

222443

Pxem, Filename: 40 bytes + Content: 0 bytes = 40 bytes.

Usage

Input is from STDIN; output from STDOUT. First positive integer N for input represents number of items in list. Then integers c1, c2, ..., cN represents each item of the list. Each input has to be separated by one or more s.

An output of Y represents truthy, and no output falsey.

Input example

List [1, 2, 3, 4, 3, 4, 5, 5, 5, 4] is:

10
1 2 3 4 3 4 5 5 5 4

With comments

XX.z
.a._\001.-.cXX.z # push N; decrement it
.a._.tXX.z # push c1; heap<-c1
.a.w\001.-XX.z # while N!=0; do N--
  .a._.c.m.-\001.xXX.z # push ci; if abs(ci-heap); then
    .a.dXX.z # exit
  .a.aXX.z # fi
  .a.tXX.z # heap=ci
.a.c.aXX.z # done
.aY.oXX.z # putchar o
.a

Link

Try it online!

222444

Pxem, filename: 7 bytes + content: 0 bytes = 7 bytes, depends on implementation.

How it works

Try it online!

222573

Pxem, Filename: 118 bytes + Content: 0 bytes = 118 bytes.

Try it online!

Usage

With comments

XX.z
# push 2^26; dup; push non-zero value;
## NOTE 2^26 is initialized table
# while empty||pop!=0; do
.a\100\100\200\200.!.!.!.cX.wXX.z
  # push getchar
  .a.iXX.z
  ## NOTE capitalizing here
  .a.c\140.x\040.-XX.aXX.z
  # if isalpha top; then
  .a.c@.x.c[.yXX.z
      # let c is difference between 'A' and the character
      .aA.-.tXX.z
      # let m is 1; what digit to see
      ## NOTE m==2^c
      .a\001.m.w\002.!\001.m.-.c.t.aXX.z
      ## NOTE actual updating table
      # if tbl&m!=1; then tbl&=m; fi
      ## NOTE no logical operators
      .a.t.c.m.$\002.%%\001.z.m.+XX.aXX.z
      # push rando character and get out
      .aXX@.aXX.z
  .aXX.aXX.z
  # get out if EOF (-1)
.a\001.+.aXX.z
# finally: if tbl==2^27-1; then putchar Y; fi
.a.t\002.!\001.-.m.z.d.aY.o

222574

Pxem, 26 bytes (filename) + 0 bytes (content) = 26 bytes.

Usage

How it works

XX.z
.a\001XX.z # push one
.a._.c.wXX.z # push getint; dup; while pop!=0; do
  .a.t.m.!XX.z # heap=pop; push heap; push pop*pop
  .a.m\001.-XX.z # push heap; push 1; push abs(pop-pop)
  .a.cXX.z # dup
.a.a.s.nXX.z # done; pop; printf "%d" pop
.a

Try it online!

222582

Pxem, Filename: 60 bytes + Content: 0 bytes = 60 bytes.

With comments

See also: Simple cat program

XX.z
# pasted cat program
.a.w.o.i.c\001.+.aXX.z
# exit
.a.dXX.z
# these literals are ignored
.a!md!T!j!b!\\!V !k!V\177!lG!|Q!vr!|KK!TKK!T!V\001!|!T

Try it online!

]'rz.

With comments

XX.z
# they are just literals but discarded later
.aXX;&;|;v;p\001;8;n;q.z
# while size<2||pop!=0; do push 'q'; done
.a.zq.aXX.z
# while empty||pop!=0; do
.a.wXX.z
  # if ! empty; then putchar pop; fi
  .a.oXX.z
  # push getchar; dup; push 32;
  # while size<2||pop<pop; do
  .a.i.c .xXX.z
    # dup; push 127; while size<2||pop>pop; do
    .a.c\177.yXX.z
      # push 84; push pop+pop;
      # push 94;
      # push ((x=pop)<(y=pop))?y%x:x%y
      .aT.+^.%XX.z
      # push 33; push pop+pop;
      .a!.+XX.z
    # push X; push X; done (* idiom for BREAK statement *)
    .aXX.aXX.z
  # push X; push X; done
  .aXX.aXX.z
# dup; push 1; push pop+pop; done
.a.c\001.+.a

a!( v# |{yv{r.

222675

Pxem, Filename: 131 bytes + Content: 61 bytes = 192 bytes.

I escaped spaces too (\040).

Actual source

Filename

c.z.e,.o .oq.e.s..o
.o.-.c.y.sGo to the store and buy some more, .pc.
.e.d.a.tTake one down and pass it around, .p.m.e..o
.o
.o.a

Content

.cd.y.t on the wall.mXXq.a.s.c.n.t of beer.m.zXXs.a bottle.p

With comments

Inspired by Dorian's answer in Whitespace at first, then golfed well. Though both Whitespace and Pxem are stack-oriented programming language, their features are different, as in these:

Overall of the program

Filename

XX.z
# push 99;
# while size<2||[ $(pop) -ne $(pop) ]; do
.ac.zXX.z
  # for i in $(reverse $(call $stack)); do
  #   push $i; done
  ## NOTE let it be "call" next time
  .a.eXX.z
  # push 44; putc $(pop); push 32; putc $(pop)
  ## NOTE DOTo is actually:
  ## if !empty; then : do above; fi
  .a,.o .oXX.z
  # push 113; call; pop
  ## NOTE 113>=100
  .aq.e.sXX
  # push 46; putchar $(pop);
  # push 10; putchar $(pop)
  .a..o\n.oXX.z
  # push 1;
  # push $(( (x=$(pop)-$(pop))<0?-x:x ))
  ## NOTE arithmetic operators actually:
  ## check if size>=2 before;
  ## NOP if size<2
  .a\001.-XX.z
  # dup; push 1;
  # while size<2||[ $(pop) -gt $(pop) ]; do
  .a.c\001.yXX.z
    # pop;
    ## NOTE literal is pushed from backwards
    # for i in 32 44 --- 71; do push $i; done
    .a.sGo to the store and buy some more, XX.z
    # while !empty; do putchar $(pop); done
    .a.pXX.z
    # push 10; push 46; push 99;
    # call
    .ac.\n.eXX.z
    # exit
    .a.dXX.z
  # done
  .a.aXX.z
  # if !empty; do heap=$(pop); fi
  # for i in 32 44 --- 84; do push $i; done
  .a.tTake one down and pass it around, XX.z
  # while !empty; do putc $(pop); done
  .a.pXX.z
  # case ${heap:+y} in (y)
  #   push $heap;; esac;
  # call; push 46; putc $(pop);
  # push 10; putc $(pop)
  # push 10; putc $(pop)
  .a.m.e..o\n.o\n.oXX.z
# done
.a.a

Content

XX.z
## NOTE subroutine stack is initialized
## to be same as that of its caller
## but its heap is initialized to be empty,
## which is not shared to its caller
## So, implicitly: stack="$*"
## NOTE when returning to subroutine,
## heap is discarded but items on its
## stack is pushed to its caller, from
## bottom to top
# dup; push 100;
# while size<2||[ $(pop) -gt $(pop) ]; do
.a.cd.yXX.z
  # heap=$(pop)
  .a.tXX.z
  # for i in 108 108 --- 32; do push $i; done;
  # push $heap;
  # push 113; push 88; push 88
  .a on the wall.mXXqXX.z
# done
.a.aXX.z
# pop; dup; printf %d $(pop)
.a.s.c.nXX.z
# heap=$(pop)
.a.tXX.z
# for i in 114 101 --- 32; do push $i; done;
# push $heap; push 1;
# while size<2||[ $(pop) -ne $(pop) ]; do
.a of beer.m\001.zXX.z
  # push 115; push 88; push 88
  .aXXXXs.z
# done
.a.aXX.z
# for i in 101 --- 32; do push $i; done;
# while !empty; do putc $(pop); done
.a bottle.pXX.z
# (* implicitly *) return $stack (* to its caller *)
.a

Try it online!

222770

M4, 224 bytes

define(b,`$1 bottle`'ifelse($1,1,,s) of beer')define(w,`b($1) on the wall')define(f,`w($1), b($1).
ifelse($1,1,`Go to the store and buy some more, w(99).',`Take one down and pass it around, w(decr($1)).

f(decr($1))')')f(99)

If I learn GNU extensions, perhaps I would shorten this code.

Try it online!

222945

Pxem, Filename: 6 bytes + Content: 0 bytes = 6 bytes.

Sorry for a boring post.

Try it online!

223076

AWK, 422 bytes

I think it took me over a week to solve this problem.

function l(x){return length(x)}{P=9(d=$2);gsub(".",FS,P);N=l(L=n=$1);gsub(".","-",L);O(0,q=int($1/$2));Q=l(q);print P L RS d"|"n}function O(i,x){printf"%"l(d)+N-Q+1+i"d\n",x}m=substr(q,1,1)*d{for(i=1;i<=Q;){O(i,m);print P substr(L,1,N-Q+1);for(_=l(j=n)-l(n-=m*10**(Q-i));_--;)P=P FS;if(!n)exit;match(q,".0*");i+=R=RLENGTH;sub(".{"R"}",E,q);b=q+0?substr(n,1,M=l(m=substr(q,1,1)*d)):n;if(b<m)b=substr(n,1,M+1);O(i-(i>Q),b)}}

Try it online!

Usage

Formatted

function l(x){
  return length(x)}
{
  P=9(d=$2);gsub(".",FS,P);
  N=l(L=n=$1);gsub(".","-",L);
  O(0,q=int($1/$2));
  Q=l(q);
  print P L RS d"|"n}
function O(i,x){
  printf"%"l(d)+N-Q+1+i"d\n",x}
m=substr(q,1,1)*d{
  for(i=1;i<=Q;){
    O(i,m);
    print P substr(L,1,N-Q+1);
    for(_=l(j=n)-l(n-=m*10**(Q-i));_--;)
      P=P FS;
    if(!n)
      exit;
    match(q,".0*");
    i+=R=RLENGTH;
    sub(".{"R"}",E,q);
    b=q+0?substr(n,1,M=l(m=substr(q,1,1)*d)):n;
    if(b<m)
      b=substr(n,1,M+1);
    O(i-(i>Q),b)}}

223081

Dash, 12 bytes

yes|sed -n =

Or, alternatively:

yes|sed =\;d

Try it online!

223086

itflabtijtslwi, 233 204 bytes

/Z/\/\///Y/\\\\ZH/Y>ZF/P.ZE/C.ZD/.BZB/\/.ZA/Y.Y./B/<Y\HYYYZP1/GGE2GG./E1E3D\./F2.\D\DB/E1D\./F2.\./p.2.AAB/E3D\D/E1E2E3./F1./F3D/p.\2./F1D/<.HDB/F\3./F1D/<.H./<.A\.H.AAA/F2ZP\2/P1Z<HZ/P\3/P1Z<H/<Y\HYYY/P2

Try it online!

Original

I am not familiar with the language well; I barely understand how the program works. This is a modification of cat program.

/./<\\\\>\\\\\\//P1/GGC.2GG./C.1C.3./.\./P.2.\./.\./././C.1./.\./P.2.\./p.2.\.\.\.\././C.3./.\././C.1C.2C.3./P.1./P.3././p.\2./P.1././<.\>./././P.\3./P.1././<.\>./<.\.\.\.\>.\.\.\.\.\.\./P.2//P\2/P1//<\>///P\3/P1//<\>/<\\\\>\\\\\\/P2

Try it online!

223091

Pxem, Filename: 29 bytes + Content: 0 bytes = 29 bytes.

Outputs fibonacci sequence, separated with space.

Try it online!

With comments

XX.z
# push 1; push $(($(pop)*$(rand)))
# NOTE rand pushes 0<=x<1
# NOTE null character cannot be used for filename
.a\001.rXX.z
# push 1; push 88; while [ $(pop) -ne 0 ]; do
.aX\001.wXX.z
  # Do I really need to explain more?
  # Just read the specification; I am going to bed
  # also a sequence .t.v.m.v is an idiom
  # to move top item to bottom
  .a.c.n.c.t.v.m.v.+ .oX.a

223095

M4, 11 bytes, cheating.

syscmd(cat)

Try it online!

223098

Pxem, Filename: 9 bytes + Content: 0 bytes = 9 bytes.

223257

Pxem, Content: 0 bytes + Filename: 54 bytes.

Usage

How it works

._XX.z
# let input be n
# get out if <2
.a.c\002.y.d.aXX.z
# let i be 2
# while i*i<=n (or i*i-1<n); do
.a.c\002\003.t.xXX.z
  # if n%i<1; then exit; fi
  .a.c.m.%\001.y.d.aXX.z
  # i++
  .a.c.m\001.+.c.t.c.!\001.-XX.z
# done; print n
.a.a.n

Try it online!

223302

M4, 49 bytes

define(f,`ifelse($1,0,1,`eval($1*f(decr($1)))')')

Try it online!

Usage

f(n)dnl where n is an integer.

223647

GAWK -M, 138 120 bytes.

It was originally a post on rosetta code. Without -M it overflows when huge value is input.

{a=2
b=3
c=5
for(s=h[0]=1;--$0;c-z||c=5*h[++k]){z=a<b?a:b
s=s" "(z=h[++n]=z<c?z:c)
a-z||a=2*h[++i]
b-z||b=3*h[++j]}}$0=s

Try it online!

Usage

Given from stdin, as a line consists of a string of decimal natural number.

Execution time

Tested in my Termux. CPU is:

Architecture:        aarch64
CPU op-mode(s):      32-bit, 64-bit
Byte Order:          Little Endian
CPU(s):              8
On-line CPU(s) list: 0-7
Thread(s) per core:  1
Core(s) per socket:  4
Socket(s):           2
Vendor ID:           ARM
Model:               4
Model name:          Cortex-A53
Stepping:            r0p4
CPU max MHz:         1768.0000
CPU min MHz:         449.0000
BogoMIPS:            52.00
Flags:               fp asimd evtstrm aes pmull sha1 sha2 crc32

With original code

10^6th Hamming number is 519312780448388736089589843750000000000000000000000000000000000000000000000000000000.

$ time echo 1000000 | awk -Mf Textfile/ham.awk
# lots of output
real    2m36.842s
user    0m25.224s
sys     0m5.356s

If $0=s is removed

$ time echo 1000000 | awk -Mf Textfile/ham.awk
real    0m25.404s
user    0m24.676s
sys     0m0.716s

Note

223653

Pxem, Filename: 58 bytes + Content: 0 bytes = 58 bytes.

Problem is that my implementation of Pxem supports literal value up to 255; needed to make greatee values by myself.

Usage

Via stdin/stdout. Accepts only one input at once.

Try it online!

223695

Pxem, Filename: 15 bytes + Content: 0 bytes = 15 bytes.

Try it online!

223709

CASL II, 55 43 bytes.

CASL II is an assembly language for COMET II, the fictional architecture. It is designed for Japan Information-Technology Engineers Examination.

Here is the page that you can obtain official specification, as Information Technology Terms and Specifications of Programming Languages Used in Examination Questions.

I've found a way to specify a literal instead of an address:

A START
 OUT ='Hello, World!',=13
 RET
 END

Previous version

55 bytes

Z START
 OUT A,B
 RET
A DC 'Hello, World!'
B DC 13
 END

Links (they are in Japanese)

223789

Hamming number (also known as regular number) is a number that evenly divides powers of 60. We already have a task to do something with it. This time we are going to do the opposite.

I define non-Hamming number as in: \$n\$ is non-Hamming number if and only if it satisfies following two conditions:

Make a program, a function, or a subroutine that does one of these:

  1. takes no input to print/return/generate a list of non-Hamming numbers infinitely, or
  2. takes a positive integer \$n\$ as input to print/return/generate \$n\$th non-Hamming number (can be either 0-indexed or 1-indexed), or
  3. takes a positive integer \$n\$ as input to print/return/generate a list of first \$n\$ non-Hamming numbers.

4. takes a positive integer \$n\$ to print/return/generate non-Hamming number until \$n\$ (suggested by @Wasif, can be inclusive or not; i.e. non-Hamming numbers that are either \$<n\$ or \$\leq n\$). abolished by @rak1507.

Example

This example shows how program/function/subroutine that does 3rd task should work:

Rules

P.S.

It's actually A279622.

224337

AWK, 92 bytes

Previously 93 bytes that outputs intfinite list.

Given a line of an integer \$n\$, outputs first \$n\$ nunbers.

Pretty naïve.

{for(k=j=7;$0--;k=++j){for(;k%2-1;k/=2);for(;!(k%3);k/=3);for(;!(k%5);k/=5);if(k>1)print j}}

Try it online!

225044

Pxem, Filename: 19 bytes + Content: 0 bytes = 19 bytes.

Now the debut of lazypxem.min.posixism.

Try it online! The footer has |od -vtu1 to be commented; uncomment it to inspect the exact output.

225045

Pxem, 0 bytes (content) + 21 bytes (filename); requires to be executed on console.

Try it online!

Try it online!Try it online!

How it works

When single, it just outputs 1; when doubled, it appends backspace character and 2; this is how it looks like as if it were doubled. If this would violate the rules, I'm sorry.

225051

Pxem (esolang-box notation), 8 bytes.

In this docker environment Pxem program, officially given as a pair of filename and its content, is given as a file:

The first line is the file name of the pxem code.

The rest is the content of the pxem code.

Original is

.f.+.n
.

which is translated to filename .f.+.n with content .. It outputs 46, which is ASCII code for ..

When doubled:

.f.+.n
..f.+.n
.

which is translated to filename .f.+.n with content ..f.+.n\n.. It outputs 92.

How it works

.f pushes content in reverse order
.+ does push (pop+pop) if size>=2; nop otherwise
.n does printf %d pop

Try it online!

Try it online!Try it online!

225054

Pxem, Content: 0 bytes + Filename: 75 bytes.

Try it online!

!Try it online

ry it online!T

With comments

??.z
# number of X's, as literals branches
.a??X.z
# if not empty; then pop; else enter here
.a.c.Z??.z
  # push while EOF
  .a.w.i.c\001.+.a??.z
  # pop; reverse; pop to heap; pop all to print; push heap; pop to print; exit
  .as.v.t.p.m.o.d??.a
.a.A??.z
# if not empty; then pop; else enter here
.a.c.Z??.z
  # cat; as in my previous post
  .a.w.o.i.c\001.+.a.d??.z
.a.A??.z
# and finally
.a.w.i.c\001.+.a.s.t.v.m.pX

225058

Pxem, 0 bytes (content) + 52 bytes (filename).

Usage

With comments

XX.z
# Initial stack: F(i-1), F(i-2), i
# i is initially 2
.a\002._._XX.z
# while :; do
.aX.wXX.z
  # to: (F(i-1)+F(i-2)), i, F(i-1)
  .a.c.t.v.m.v.+XX.z
  # input is F(i)
  # to: F(i), (F(i-1)+F(i-2)), i, F(i-1), F(i)
  .a._.c.t.v.m.vXX.z
  # to 0, abs(F(i)-F(i-1)-F(i-2)), i, F(i-1), F(i)
  # if (pop!=pop); then
  .a.-\001.r.xXX.z
    # print pop; exit; fi
    .a.n.d.aXX.z
  # to F(i), F(i-1), (i+1)
  .a\001.+.vXX.z
# done
.aX.a

Try it online!

225059

Pxem, Numeric: 34 bytes + Non-numeric: 21 bytes = 55 bytes.

The boring answer. The stupid latter part is nothing but a garbage.

Try it online!

225104

CASL II, 72 bytes.

Tested here.

A START
 IN B,1
D OUT B,1
 LAD GR1,48
 XOR GR1,B
 JNZ D
 RET
B DS 1
 END

If you are familiar with assembly languages, you would get it well. It uses standard i/o. It uses ASCII-compatible encoding.

225107

Pxem, 0 bytes (content) + 13 bytes (filename).

Filename is:

._.c.n.w1.o.a

Try it online!

As verbose pseudocode

push numeircal integer input
dup
unless empty: printf "%d", $(pop)
while one of
  1. empty
  2. $(pop) != 0
do
  push "1", a character
  unless empty: printf "%c", $(pop)
done

225108

Pxem (esolang-box notation), Hello World: 48 bytes + Quine: 110 bytes = Cat: 158 bytes.

Unprintables are escaped.

Hello World

.f!.zHello World.p.d.a.w.c.z.w.o.i.c\001.+.a.d.a.a

Quine

!Be!?BzBc!!B+BzXXFBaBcFBzBsXXFBBaBsBtBvBmBvBcAcB-BaBsBp".e!?.z.c!!.+.zXXF.a.cF.z.sXXF..a.s.t.v.m.v.cAc.-.a.s.p

Cat

.f!.zHello World.p.d.a.w.c.z.w.o.i.c\001.+.a.d.a.a
!Be!?BzBc!!B+BzXXFBaBcFBzBsXXFBBaBsBtBvBmBvBcAcB-BaBsBp".e!?.z.c!!.+.zXXF.a.cF.z.sXXF..a.s.t.v.m.v.cAc.-.a.s.p

Try it online!

Use variable mode to switch programs.

How it works

The Hello World program consists of several parts, as in:

# branch if content begins with '!' or not
.f!.z
  # Hello World program
  # Note that '!' is recycled here
  Hello World.p.d
.a
.w.c.z
  # Cat program
  # Note that content of stack is cleared before entrying here
  .w.o.i.c\001.+.a.d
.a.a\n

Quine is recycled from here.

Cat program uses this specification:

The first line is the file name of the pxem code.

The rest is the content of the pxem code.

225118

Pxem, 0 bytes (content) + 147 bytes (filename).

Try it online!

Usage

A single line that matches ^[0-9]+$, ending with EOF, is given from stdin. A single Y is output if and only if truthy.

Algorithm

  1. Let l1 be a list storing each digit in reverse order.
  2. Let s be 0.
  3. Let l2 be an empty list.
  4. If l1 is empty, go to step 9.
  5. Pop one value from l1 and let it be n. Push n*(s+1) onto l2.
  6. If last value on l2 is more than 9, subtract 9 from it.
  7. Let s be 1-s.
  8. Go to step 4.
  9. Calculate (sum of each item in l2)%10.
  10. If step 9 resulted in 0, the program returns truthy; otherwise falsey.

With comments

# getchar() unil EOF
# substract 48 for each character
.w0.-.i.c\001.+.aXX.z
# at this point stack is -1, [0-9], ..., [0-9], 48.
# add 1 to -1 so: 0, ..., 48.
# move 0 to bottom: [0-9], ..., 48, 0.
.a\001.+.t.v.m.vXX.z
# loop
# every time loop begins, bottom should be [01].
# also heap should be same as bottom.
.aQJ.zXX.z
  # to: [0-9], [01], ..., 48, ..., [01]... I think
  # WTF did I do here?
  .a.v.m.v.c.m.+.c.t.-.m.v.t.v.m.-.mXX.z
  # multiply [0-9] to ([01]+1)
  .a\001.+.!XX.z
  # subtract 9 if more than 9
  .a.c\011.x\011.-XX.aXX.z
  # move top to bottom, replacing it
  .a.t.v.s.m.vXX.z
  # alt for [01] xor 1; subtract from 1
  # then move to bottom
  .a\001.-.t.v.m.vXX.z
# break if top equals 48
.a.c0.aXX.z
# make 48 to 10, then remove botton [01]
# OBTW reversed, but whatever
.a\046.-.v.sXX.z
# loop
.a@.wXX.z
  # if size is 1; then
  .a.t.c.c.ZXX.z
    # modulo by 10
    .a.m\012.%XX.z
    # if it is 0; then print Y and exit; else exit; fi
    .a.w.d.aY.o.d.AXX.z
  # fi; push (pop+pop)
  .a.m.+
# end of loop
.a@.a

225122

Pxem, 0 bytes: content + 30 bytes: filename.

Algorithm

  1. Push "ceraft".
  2. Generate a random number between 0 to 9999.
  3. Unless it is 1, fix the string "ceraft" with "ecraft".
  4. Insert "Min" and print it.

Try it online!

225160

Pxem (esolang-box notation), 43 bytes.

Some unprintables are escaped.

.e
e.z\001.rXX.a.w.s.p.d.a.w.c.o.i.cED.-.+.ae.

Parindromed

.e
e.z\001.rXX.a.w.s.p.d.a.w.c.o.i.cED.-.+.ae..ea.+.-.DEc.i.o.c.w.a.d.p.s.w.a.XXr.\001z.e
e.

With comments

For parindromed.

XX.z
# MAIN ROUTINE
# call with empty stack
.a.eXX.z

# SUBROUTINE
# should be called with either 
.aXX.z
# if top is not e, then push zero
# else e is popped
.ae.z\001.rXX.aXX.z
# if top is not zero, then print and pop each item
# (except top .; discarded) and return
.a.w.s.p.d.aXX.z
# cat program BUT preserve each item
# XXX: where does EOF: -1 go?
.a.w.c.o.i.cED.-.+.aXX.z
# NOTE if not parindromed, the next section and so far is e.,
# which .e and so far would not be there
# if parindromed, call with stack
.ae..eXX.z
# garbage, then reaching to .D returns to main section
.aa.+.-.DXX.z
# and garbage
.aEc.i.o.c.w.a.d.p.s.w.a.XXr.\001z.e\ne.

Try it online!

225165

Pxem, 0 bytes: content + 170 bytes: filename.

H(X) = 3.57662

Try it online!

How it works

225238

Vyxal, 29 26 bytes, times out when n>=200,000 on online interpreter.

My first ever Vyxal post. 29->26, adviced by @lyxal.

6ɽ{:L?<|:2*$:3*$:5*∪∪∪}s?Ẏ

How it works

# let first hamming numbers are 1 to 6
6ɽ
# while items of they are less than n; do
{:L?<|
# for each item, multiply with those numbers
# and then unify them; done
  :2*$:3*$:5*∪∪∪}
# sort
s
# take first n items
?Ẏ

Try it Online!

225275

Pxem, W: 87.

Characters are: !-.01ACDOVW (but ! can be any others, and O can be anything that works as pop one and discard it).

Here's how to emulate cyclic tag system program (101,001,10) with input 1, for example, in Pxem (??.z ... .a is pseudo-comment; can be erased):

??.z
# input is 1
# then loop begin
.a!1.W??.z

  # exit if empty
  .a.C.C.-.W.D.A??.z
  # append 101 if top is NOT 0
  .a.C0.-.W.V101.VWW.-.A??.z
  # erase top (by printing it)
  .a.O??.z

  # exit if empty
  .a.C.C.-.W.D.A??.z
  # append 001 if top is NOT 0
  .a.C0.-.W.V100.VWW.-.A??.z
  # erase top (by printing it)
  .a.O??.z

  # exit if empty
  .a.C.C.-.W.D.A??.z
  # append 10 if top is NOT 0
  .a.C0.-.W.V10.VWW.-.A??.z
  # erase top (by printing it)
  .a.O??.z

# end of loop  
.a!.A

Try it online!

225276

AAAAAAAAAAAAAA!!!!, Score: 65 (A).

Characters are ! ,A.

Proven as in this.

226297

Pxem, 0 bytes (for content) + 50 bytes (for filename).

Usage

With comments

XX.z
# let counter is 127
.aM\177XX.z
# loop
.a.wXX.z
  # c = getchar()
  .a.iXX.z
  # increment here
  .a.c;.-\001.y.s\001.+;;;.aXX.z
  # output and reset here
  .a.c#.-\001.y.s\177.%.o###\177.aXX.z
# break if c is EOF
.a\001.+.a

Try it online!

226303

AWK, 109 102 bytes

-7 bytes; thank you, @ovs!

Pretty naïve.

a=1{for(p=2;i++<length;)for(a*=p++**(index("0s~|A()",substr($0,i,1))*(j=2)-1);j<p;)p%j++||p++<j=2}$0=a

Try it online!

Ungolfed

{
# accumulator and currently seeing prime number
a=1;p=2;
for(i=1;i<=length($0);i++){
   # multiply p_i^(x_i)
   a*=p**(index("0s~|A()",substr($0,i,1))*2-1);
   # get next prime
   p++;
   for(j=2;j<p;)
      if(p%j!=0)
         j++;
      else{
         p++;j=2;}}
# finally
$0=a

226530

11. Ross Long, Pxem, 0 (content) + 17 (filename).

Since it was 15 bytes, terminating LF is also output.

Filename is as follows:

#>&:*.@
~2-1??
.p

Content is empty.

Try it online!

My first post:

226745

Pxem, 0 bytes (content) + 3 bytes (filename).

226747

Pxem, 12 bytes (content).

Unprintable characters are escaped.

.c\001.y.s\001.d.a

Usage

Usage example

Filename to be _.e.n, with your input from stdin.

226751

Pure yash and echo (or POSIX-compatible shell), 42 bytes

Separator is space or LF.

while echo ${#a} ${a+-${#a}};do a=.$a;done

How it works

Try it online!

226752

Pxem, 9 bytes (filename only), $192255.

Try it online!

226798

yash, 50 bytes

This is POSIX-compatible.

echo Programming Puzzles||echo${IFS}Code${IFS}Golf

How it works

Like @NahuelFouilleul but using IFS variable instead.

Try it online!

Tryitonline!

226799

Pxem, filename: 47 43 bytes.

  .zAaGolf.-Code.p.d.aProgramming Puzzles.p

What it does

Branches with first two spaces.

Try it online!

Tryitonline!

226838

Pxem, 99 bytes, score: \$\approx2.63\times10^{22183}=10\uparrow\uparrow2.63809\$.

Unprintables are escaped.

.z\377.n\001.+.c\377\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+\377.+.a.n

I think it could be more, with x-ple loops.

Output: \$(255\sum_{k=0}^{7394}{1000^k})\times10000+7395\$ (I think)

Try it online!

226898

Pxem

Pxem is an esoteric language designed by "ぬこ" (now "nk."), published in 2008. Unlike many other languages, filename matters first and content is second; that is, a Pxem program consists of two strings.

0 bytes

If content is empty, calling .e is equivalent to duplicating entire stack.

1 byte

.

Every command has this prefix; this may be awkward when you want to push the character directly, on some problems.

3 bytes

\001.r

My favorite idiom to push zero on filename. As filename cannot contain NULL character (usually), this would be needed.

4 bytes

XX.z

My favorite idiom to begin pseudo comment.

6 bytes

.c.c.z

My idiom to check if stack is empty or not; goes inside if stack is empty; does not otherwise.

228910

Bash, 25 bytes

bc<<<'for(;i++<10^100;)9'

Try it online!

bc, 18 bytes

for(;++i<10^100;)9

Why is TIO broken so it won't work unless coding in header?

Try it online!

229544

Zsh + coreutils, pxeger's post, cracked after being safe.

Password.

${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)} ${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}${(#)$((){<<<$#} $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $)}

Try it online!

What original program does

How I cracked

229550

Pxem, filename only: 51 bytes.

Emulating stack with stack-based language. \001 is unprintable character 0x01.

.w._.c.w.cXXX.-.a.s.s.c\001.+.a.sL.w.n.c.c.z.d.a,.oL.a

Try it online!

Usage

How it works

XX.z
# while stack is empty or pop!=0; do
.a.wXX.z
 # get integer from stdin, and push it
 .a._XX.z
 # dup; while pop!=0; do
 .a.c.wXX.z
  # dup; push dummy item; break; done
  .a.cXXX.-.aXX.z
 # pop twice and discard them
 .a.s.sXX.z
# dup; add one; done
.a.c\001.+.aXX.z
# pop
.a.sXX.z
# while :; do
# NOTE L is for dummy
.aL.wXX.z
 # pop and print it as an integer
 .a.nXX.z
 # dup; dup; while size<2||pop!=pop; do exit; done
 # NOTE dup is not done if empty
 .a.c.c.z.d.aXX.z
 # print a comma; done
 .a,.oL.a

229552

Pxem, filename only: 11 bytes.

0.z1.o.a0.o

0Try it online!

1Try it online!

If you are not familiar with Pxem: .z ... .a is "while stack size<2 or pop!=pop; do something; done" (sorry I misdescript the function).

Also, pushing literates are done backwards; if program begins with 10.z, then 48 is pushed first, then 49 next. Then the branching is done.

229556

Zsh, cracks pxeger's post, cracked after being safe.

Did I get the rules correctly?

a=1;: " 
#include <cstdlib> 
#include <iostream> 
 
int main() { 
    srand(time(NULL)); 
    hello(); 
    return rand() % 2; 
} 
 
/* 
  main 
  a=0 
  \ 
  print "$((1/$a))" 
*/ 
 
void hello() std::cout << "Hello, World!" << std::endl; 
 "

Try it online!

229557

Pxem (lazypxem.posixism.tio.sh (8e9ac7ceb2)), filename only: 109 bytes, safe safe.

Sorry for misreading the rules; I misread I would safe if nobody cracked mine for one week; I had to wait for two weeks to be safe.

Some are escaped:

\002.r.w.i._._.-.-\240.z.d.aY.o.d.a\002.r.w.i.i.i.i.s.s.s.s._.i.!Q##.!.-.+.w.d.aY.o.d.a.w.+.i.c\001.+.a.+\377\377].+.+.z.d.aY.o

Try it online!

Hint (posted after 5 days and 2 hours later, I think)

Intended password

z317-35bP

229713

Pxem (lazypxem.min.posixism), score: 255.

I annotated who are not ASCII printables as octal, prefixed by a backslash. One snippet per line.

\001
\002
\003
\004
\005
\006
\007
\010
\011
\012
\013
\014
\015
\016
\017
\020
\021
\022
\023
\024
\025
\026
\027
\030
\031
\032
\033
\034
\035
\036
\037
 
!
"
#
$
%
&
'
(
)
*
+
,
-
.
/
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
^
_
`
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
{
|
}
~
\177
\200
\201
\202
\203
\204
\205
\206
\207
\210
\211
\212
\213
\214
\215
\216
\217
\220
\221
\222
\223
\224
\225
\226
\227
\230
\231
\232
\233
\234
\235
\236
\237
\240
\241
\242
\243
\244
\245
\246
\247
\250
\251
\252
\253
\254
\255
\256
\257
\260
\261
\262
\263
\264
\265
\266
\267
\270
\271
\272
\273
\274
\275
\276
\277
\300
\301
\302
\303
\304
\305
\306
\307
\310
\311
\312
\313
\314
\315
\316
\317
\320
\321
\322
\323
\324
\325
\326
\327
\330
\331
\332
\333
\334
\335
\336
\337
\340
\341
\342
\343
\344
\345
\346
\347
\350
\351
\352
\353
\354
\355
\356
\357
\360
\361
\362
\363
\364
\365
\366
\367
\370
\371
\372
\373
\374
\375
\376
\377

What they do

They are snippets. They just push their own codepoint to stack. Because my interpreter just treats each byte to be unit, any sequences of bytes can be snippets.

If you think my answer is not qualified as a function: make a content that consists of just one of those snippets, and call it with .f on filename; this is how my snippets work like functions.

Notes about snippets

229721

Pxem, 9 bytes (filename).

~~~.n.n.n

Output:

126126126

How it works

Try it online!

229739

Pxem, 56 bytes (content)

Unprintables are as backslash followed by its code point in octal.

.c.w\000\001\001.v.c.t.y\002.!.c.m.v\001.+.v.a.m.z\001.-XX.a.v.n.d.a.s-1.p

Usage

With comments

XX.z
# if top is not zero; then
.c.wXX.z
  # stack usage: input, 2^counter, counter(initially zero)
  .a\000\001\001.v.c.tXX.z
  # while input is greater than 2^counter; do
  .a.yXX.z
    # increment counter; done
    .a\002.!.c.m.v\001.+.v.aXX.z
  # if input differs from 2^counter; then decrement counter; fi
  .a.m.z\001.-XX.aXX.z
  # output counter; return
  .a.v.n.dXX.z
# done; output minus one
.a.a.s-1.p

Try it online!

229742

Pxem, filename: 17 bytes.

\001 is such a byte of binary.

.w.o.o.i.c.c\001.+.a

How it works

Since this program is simple, here is verbose explaination.

XX.z
# while stack is empty or popped value is not zero; do
# NOTE stack is initially empty
.a.wXX.z
  # if not empty; then pop to output its character; fi
  # if not empty; then pop to output its character; fi
  .a.o.oXX.z
  # getchar and push its codepoint value
  # NOTE EOF is -1
  .a.iXX.z
  # if not empty; then duplicate; fi
  # if not empty; then duplicate; fi
  .a.c.cXX.z
  # push one
  # if stack has two or more items; then pop twice and push their sum; fi
  .a\001.+XX.z
# done
# NOTE reaching to end of filename implicitily terminates the program
.a.a

Try it online!

229959

Pxem, 66 bytes (filename).

Unprintables are as a backslash followed by its code point in three-digit octal.

\001.t.z\002.r.wzun.p.m\001.+.t\001o.r.ao.zdok.p.m\004.xki-yo-shi!.p.d.a\001.tXX.a.a

With comments

XX.z
# heap: 1 as counter
.a\001.t.zXX.z
  # choosing either zun or doko
  .a\002.r.wXX.z
    .azun.pXX.z
    # increment counter
    .a.m\001.+.tXX.z
    # push o for next dot-z and get out
    .a\001o.r.aXX.z
  # if empty; then push o and get in
  # else pop it and ignore next block
  .ao.zXX.z
    # reusing the o
    .adok.pXX.z
    # print kiyoshi and exit if counter is >4
    .a.m\004.xki-yo-shi!.p.d.aXX.z
    # else reset counter to 1
    .a\001.tXX.aXX.z
# pop a garbage of an o if any
.a.a

Try it online!

229961

Pxem, 58 bytes (filename).

Because Pxem does not handle decimal values nor negative values (negative values can be supplied via input but cannot be generated in other ways), I am representing them as integers.

Unprintables are represented as a backslash followed by three-digit octal value of its code point.

x\003\144.w\002.r\002.!+.+.o.v21.y.c\013.r.c.t.c.!.a.m.n.m.m.!.-.v\001.-.c.a

Output format

It outputs 10x, 10y, and 10z rather than x, y, and z.

"%c%d%c%d%c%d\n", sign, value, sign value, sign, value

Sign is as either + or -; always output. Value is multiplied by 10. Thus the precision of the program is up to 0.1.

With comments

XX.z
# memory layout: counter, l
# until counter is zero; do
.ax\003\144.wXX.z
  # output sign
  .a\002.r\002.!+.+.oXX.z
  # while :; do
  .a.v21.yXX.z
    # generate a random number 0<=x<=10
    .a.c\013.rXX.z
    # continue if x^2>l; otherwise break
    .a.c.t.c.!XX.z
  # done
  .a.aXX.z
  # output x
  .a.m.nXX.z
  # update l to l minus x^2
  .a.m.m.!.-XX.z
# decrement counter; done
.a.v\001.-.c.a

Try it online!

229963

Bash, 58 bytes

Just a modification of @stephanmg's post in Bash. Output is on STDERR as in "command not found".

case $1 in
*1?|*[04-9])$1th;;*1)$1st;;*2)$1nd;;*)$1rd
esac

Try it online!

This program completely relies on the limitation that the input is a non-negative decimal integer.

229964

Pxem, 6 bytes: filename.

First two characters are as escaped notation.

\303\003.$.p

Try it online!

230204

Dis, 0 bytes.

Yes, a blank program:

How it works

Since TIO doesn't have Dis by native, I made the interpreter. Try it online!

230293

BrainCrash, 14 bytes.

Note that this is NOT Braincrash; this is also a Brainfuck-variant, with these expansions:

Here is the program:

>>>>>>^<<<<<<<

What it does

Try it online! The interpreter was originally written by "ぬこ", the designer of the language; I modified a bit for TIO.

230328

BrainCrash, 21 12 bytes

[[[...>>>]]]

Try it online!


Previously:

...^...^...^[[[>>>]]]

Try it online!

230354

Dis, 49 bytes.

}{*|*^__________!||_^_____________*{___^___****!*

Usage

With comments

(
0: }{*|*^
'*'+1: ****!* 

'*'+1: * changed to 48-42or49-42 by |:
   12 10t - 11 20t is 01 20t is 15
   12 11t - 11 20t is 01 21t is 16 

'*'+2: * for * command 

'*'+1: 15or16 for ^ 

15+1: ! reaches when zero
16+1: ||^ reaches when one 

obtw '*'+3: * and '*'+4: * are for | to have the register A have 49 again 

'*'+5: ! for ^ 

After that '*'+4: '1' BUT whatever 

'!'+1: *{___^ repeatedly output one 

* 42 ! 33 

) 

(
0123456789 0123456789 0123456789 0123456789
)
}{*|*^____ ______!||_ ^_________ ____*{___^
(
0123456789 0123456789 0123456789 0123456789
)
___****!*

Try with 0!

Try with 1!

230362

Dis, 21 18 15 bytes

{{{|{{{|{{{!!!|

Try it online!

230439

Dis, 2 bytes.

}{

Olmstead's cat program is too long, and it does not do really use the features of the language; just use that non-commands are NOP and the program counter loops over! Though the output would be slow, but this is pretty simple.

Try it online!

230533

Dis, 1 byte.

{

Outputs infinite amount of NULL characters; may be slow, depending on the implementation.

230905

Pxem, 113 bytes (filename).

Here is filename (some characters as backslash with its code point in three-digit octal):

xHJG\071\070b\015\001\021\001\242\005\001l\215\400\344\236&kl\005\262\065&-\001\001\001\001\015\001\021\001\001\003\067\205\210i\014\352k\205\015B\005g.\326\030e\317z]&\012\015\206S\231\061\225\215\311K\256\005\264J\252\262\002\263\220\374\224\373>\007\253\007%\262q&j\271\226\245\001\001<.w\001.-.o.c.c.z.d.aX.a

Outputs as GIF.

How it works

Just as @nietthedarkabsol's, but had to add one to every byte, as the original GIF contains null chacters, which is illegal for filename. Then I just decrement each of them to output them. If I had an implementation whose .w breaks from the loop when stack is empty (nk. actually specified on the original page but no one has ever complied with it, including himself), then the final part could be golfed to: .w.o.c.a.

231143

Perl -p, with the following restrictions ppencode, 15 bytes.

print while sin

Try it online!

How it works

Alternatives

sin can be replaced with one of following keywords:

abs int oct hex

231156

Perl 5 using only keywords with lowercase alphabets only separating each of them only a space, 227 129 bytes

eval q y print chr length xor s qq q while uc le q q q x length q q truncate tie q x length q q foreach q y for q q q x ord q q q

Try it online!

How it works

eval q y
      print chr length
      xor s qq q
   while
      # default variable has spaces only; equibalent to $_
      uc
      # instead of <=126
      le q q q
         # 126==14*9
         x length q q truncate tie q
         x length q q foreach q
# just noticed i could golf the word
y for q q q x ord q q q

Previous: 227 bytes.

eval q y print chr length xor s qq q while chr length lt chr length q q length length length length length length length length length length length length length length length length length length q y foreach q q q x ord q q q

Try it online!

How it works

Using length of default variable to be accumulator.

eval q y
      # print chr($accumulator)
      print chr length xor
      # increment it
      s qq q
   while
      # instead of <
      chr length lt
      # 127 is unfortunately a prime; any efficient ideas within the restrictions?
      chr length q q length length length length length length length length length length length length length length length length length length q
# $accumulator=32
y foreach q q q x ord q q q

231172

Pxem (ぬこ's intended specification) and Pxem (pxemi.7z: his actual implementation), 16 bytes.

Filename:

.wcba.p.d.aabc.p

Content is empty.

What it does

ぬこ, the designer of Pxem, originally intended that .w should NOT get into the loop when stack is empty, but his reference implementation does not satisfy it: it gets into the loop when stack is empty. This is why none of we, implementers, have ever complied his intended specification at all.

231255

Vim, 6 bytes, cracks Aaron Miller's

<C-w>n<Esc><Esc>ZQ

What it does


Vim, 5 bytes, cracks Aaron Miller's

<C-w>n<Esc>ZQ

Same as above.

231532

Perl 5 -p, A005843, score:16, safe.

 .0123456789aelv

A simple problem. You should solve this easily if you are familiar with the language well.

Intended solution

eval 36.95.42.61.50 How it works: version number such as 5.10.3 is represented as a string. So, you just need to construct a version number to be evaluated. Example: v33 is '!'.

231538

Dis, Score: 1, cracked by Dingus

{

I have never thought of constructing the program when I posted this.

PS. Rule clarification.

Intended solution

*|||*__>*__>_||^___________________________*!**}}*! Try it online! Link to my interpreter, with comments. This uses that 123=11120t=1-11122t-11122t. To produce 1 I had to make 00100t first by 0-01020t-01120t-01120t. Then I did it > twice.

231566

Perl 5 -n, A000290: the squares, score:18, safe.

 ;cdeghijklnopqrst

Rules

Intended solution

int or print;int or die;int ne length q q q or print;int ne length q q q or die;s ss s;chr sqrt length eq chr or redo;print length

Try it online!

Usage: from stdin, as a decimal integer. 0-indexed. Can accept only a line. Input shall match /^\d+$/. No trailing LF to your input. Output from stdin, as decimal integers. If your input is 0 or 1, the program dies but please don't care for such thing; this specification is just for this challenge.

231571

Pxem, 53 bytes (filename).

Been a while since my last post of Pxem.

Backslash followed by three digits of octet: a character whose codepoint is so:

._.c\001.y\001.r.-\002.!XX.a.c\003.x.c\004.%.w.d.a\004.$.c\003.a\001.z.d.aY.o

Try it online! Through this problem I noticed a bug in my interpreter. Maybe I need to redesign the interpreter; shortening the code makes maintainance difficult.

Usage

How it works: with comments

XX.z
# push an integer of input
.a._XX.z
# NOTE Pxem does not have negative constants
# So negative inputs must be changed to positive
# and then get multiplied by two
.a.c\001.y\001.r.-\002.!XX.aXX.z
# Pxem does not have log() nor something similar
# Just keep dividing by four
# And exit if it seemed not to be 4^n
.a.c\003.xXX.z
  .a.c\004.%.w.d.aXX.z
  .a\004.$XX.z
.a.c\003.aXX.z
# final check for <4
.a\001.z.d.aY.o

231692

Dash (SUSv2-compatible?), 202 200 193 169 138 137 bytes

Usage.

I think I should change the language for golfing off.

Notes about 138 and 137 bytes:

s='for(;++i<7;){D=substr($0,i,1);printf substr(" .'\'':",(h?D%4:D/4)+1,1)}i=h++'
echo ${1-`date +%H%M%S`}|tr -d :|awk "{$s;$s}"|fold -w 6

Try it online!

231696

Pxem (esolang-box notation), 21 bytes.

I originally posted this as a cheating quine, which I noticed it disqualified for the problem.

.fak.-.f.p
.fak.-.f.p

Try it online!

How it works

In this notation,

ak.- is an idiom to push LF; .p pops each item to print them.

231697

COMET II ("CASLシミュレータ (CASL II 対応)" by Daytime), 28 bytes.

The leftmost column shows an address, and one word is two bytes.

0000: 7001 0000 7002 0000
0004: 1210 0012 1220 0014
0008: F000 0002 7120 7110
000C: 1210 006C 1110 0012
0010: 6400 0000 004C 006F
0014: 0002

The simulator seems to output an LF automatically every time OUT is executed, and it requires you to set a break point to see how it works by step by step.

Original CASL II assembly program (63 bytes)

A START
 OUT Z,=2
 LAD GR1,108
 ST GR1,Z
 JUMP A
Z DC 'Lo'
 END

Usage example

Run just for a few steps, as I have no ideas how to scroll back the console.

Run just for a few steps, as I have no ideas how to scroll back the console.

232985

Pxem (pxem.mktemp.emb.posixism, BREAK_LOOP_WHEN_INSUFFICIENT=1), filename only: 33 bytes.

The \0001 is an unprintable whose codepoint is 0x01.

[<>+-,.].i.t@.w.m.-\0001.yT.o.d.a.c.a

Try it online!

Accepts one character from stdin as an input. Outputs a T for truthy, nothing for falsey.


Pxem (pxem.mktemp.emb.posixism, BREAK_LOOP_WHEN_INSUFFICIENT=0), filename only: 42 bytes.

The \0001 is an unprintable whose codepoint is 0x01.

[<>+-,.].i.t@.w.c.c.z.d.a.m.-\0001.yT.o.d.a@.a

Try it online!

Accepts one character from stdin as an input. Outputs a T for truthy, nothing for falsey.

233000

Pxem, filename only: 11 bytes.

Uses reference implementation feature: doesn't break the loop of .w and .a when stack is empty.

L.o.wol.p.a

OR

L.z.p12ol.a

Try it online!

233001

Perl 5 (ppencode-cpmpatible), 87 bytes

print q pop xor print chr ord q else while length or print uc chr ord q else and s qq q

Try it online!

How it works

# NOTE: q x STR x eq ' STR '
# chr ord STR to obtain first character
   print q pop xor
   print chr ord q else
while
# default variable is initially empty string
   length or
      # print first L
      print uc chr ord q else and
      # make sure not to come here
      s qq q

233018

Perl 5 (ppencode-compatible), 64 bytes

You didn't clarify that I must separate each with exactly one character, so here it is mine.

print length uc xor s qq q xor print while length ne ord qw q eq

Try it online!

Explained

   # print(length) did not work for zero as $_ is not defined at then
   print length uc xor
   s qq q xor
   # delimiter
   print
while
   # equals to: length ne 101
   length ne ord qw q eq

233029

Perl 5 (ppencode-compatible), 1232 690 bytes

Today I learned that and has higher precidence than or or xor; I suffered from making a proper control flow

eval q y eval q x ord or return cos while chop and chop and chop x and print chr ord uc qw q for q and print chr ord q tie gt and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc y xor eval q y print uc chr ord q dbmopen and and print chr ord q dump and and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos if length q q s s q eq chr ord reverse length or not chr ord reverse length y or eval q x print length unless length q q s s q eq chr ord reverse length or not chr ord reverse length x xor print chr hex qw q and q while s qq q and length ne ord qw q eq

Try it online!

How it works

# fizz part
eval q y
   # if(length%3==0)
   eval q x
      # instead of length or return 1
      ord or return cos
   while
      # instead of s/...//
      chop and chop and chop
   x and
 
   # print 'Fizz'
   print chr ord uc qw q for q and
   print chr ord q tie gt and
   print chr length q else x oct oct ord q eq le and
   print chr length q else x oct oct ord q eq le and

   # for truthy
   return cos
for
   # instead of $_
   uc
y

xor

# buzz part
eval q y
   # print 'Buzz'
   print uc chr ord q dbmopen and and
   print chr ord q dump and and
   print chr length q else x oct oct ord q eq le and
   print chr length q else x oct oct ord q eq le and

   # for truthy
   return cos
if
   # instead of length%5, /[05]$/
   length q q s s q eq chr ord reverse length or
   not chr ord reverse length
y

or

# this block is done when length%15==0 or length%3&&length%5
eval q x
   print length
unless
   # instead of length%5
   length q q s s q eq chr ord reverse length or
   not chr ord reverse length
x

xor

# newline
print chr hex qw q and q


while
   s qq q and

   # ord qw q eq == 101
   length ne ord qw q eq

Previous

eval q y eval q kill and length or return cos while s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and ok and print chr ord uc qw q for q and print chr ord q tie gt and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and print uc chr ord q dbmopen and and print chr ord q dump and and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc y or eval q y eval q kill and length or return cos while s q qq and s q qq and s q qq and s q qq and s q qq and ok and print uc chr ord q dbmopen and and print chr ord q dump and and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc y or eval q y eval q kill and length or return cos while s q qq and s q qq and s q qq and ok and print chr ord uc qw q for q and print chr ord q tie gt and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc y or print length xor print chr length q q x x x x eq while s qq q and length ne ord qw q eq

Try it online!

Explained

# fizzbuzz part
eval q y
   # length%15==0?
   eval q k
         ill and length or return cos
      while
s q qq and s q qq and s q qq and
s q qq and s q qq and s q qq and
s q qq and s q qq and s q qq and
s q qq and s q qq and s q qq and
s q qq and s q qq and s q qq and o
   k and
   # then print FizzBuzz, as in first ppencode
   print chr ord uc qw q for q and
   print chr ord q tie gt and
   print chr length q else x oct oct ord q eq le and
   print chr length q else x oct oct ord q eq le and
   print uc chr ord q dbmopen and and
   print chr ord q dump and and
   print chr length q else x oct oct ord q eq le and
   print chr length q else x oct oct ord q eq le and
   # cos is for TRUTHY
   return cos
 # don't change $_ outside 
 for uc
# buzz part, like above
y or eval q y
   eval q kill and length or return cos while s q qq and s q qq and s q qq and s q qq and s q qq and ok and print uc chr ord q dbmopen and and print chr ord q dump and and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc
# fizz part, like above
y or eval q y
   eval q kill and length or return cos while s q qq and s q qq and s q qq and ok and print chr ord uc qw q for q and print chr ord q tie gt and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc
# no special strings
y or print length
# print LF
xor print chr length q q x x x x eq
# pretty familiar, isn't it?
while s qq q and length ne ord qw q eq

233077

This problem is inspired from shinh's problem.

Given an input of positive integer \$n\$, output a smiley triangle (see below) with \$n\$ rows.

Detailed rules

Valid output syntax

Assuming ASCII encoding. A smiley triangle with \$n\$ rows triangle(n), where n>=1, should be output. <0xXX> is a character with such codepoint, in hexadecimal.

triangle(n) = triangle(n) <0x0a> | triangle_(n)
triangle_(1) = <0x3a> spaces
triangle_(n) = triangle_(n-1) <0x0a> row(n) spaces
row(2) = <0x3a> <0x2d>
row(n) = row(n-1) <0x29>
spaces = <0x09> spaces | <0x20> spaces | *empty*

Example outputs

If n is 1, then

:

If n is 2, then

:
:-

If n=5, then

:
:-
:-)
:-))
:-)))

233088

M4, 88 bytes

Just a port of the syntax in OP.

define(g,`ifelse($1,2,,`)g(decr($1))')')define(f,`ifelse($1,1,:,`f(decr($1))
:-g($1)')')

Try it online!

Usage

f(number here)

233197

Perl 5 (ppencode), 35 33 bytes

print uc chr ord qw s abs while x

Try it online!

Previous

print uc chr ord qw s abs while exp

Try it online!

Alternatively:

print uc chr ord qw s abs while cos

233227

Dis, 2 bytes.

))

How it works

233237

Perl 5, score: 38, safe.

No modules.

"#'$&;)+!,-./%07*245@6|89<>31:?\]^_`}~

I think this is still an easy problem.

Hint

Solution

There can be some solutions; one is print chr length for qw x XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX x. Try it online! How to generate the solution

233358

Pxem (ABORT_ILLEGAL_INTEGER=0), 139 bytes (filename only).

Backslash followed by four-digit of octet character means a character with the codepoint. Also this uses a implementation-defined feature that "pushes zero for non-integer input for ._", which is adopted from nk.'s pxemi.7z (though the implementation is terrible).

._\0012.!.i.s.i0.-.+\0012.!._.+.c\0030.x.c\0031.$.n\0031.%.t quarter .p.mBB.a.c\0011.x.c\0012.$.n\0012.%.t dime .p.mBB.a.c\0004.x.c\0005.$.n\0005.$.t nickel .p.mBB.a.c.w.n penny.p.d.a

Usage

Try it online!

233361

Malbolge, 271 bytes

Generated here (linear generator). I tried other methods too but it took me pretty long time so I could not wait for completion.

D'`_:pon}}kXyxx5R-,s0Npn9+k#(EgDU0zyba+u)]xwvunV3210/.-,+*hg`H^c\"`_AW\UyxwvutsrqpJIHMLEDCg*@E>ba`_^]\[ZY9y765.-,+O/.nmJIHGFEDCBAya}|{ts9wvunV3210/.-,+*hg`H^c\"`_AW\UyxwvutsrqpJIHMLEDCg*@E>ba`_^]\[ZY9y765.-,+O/.nmJIHGFEDCBAya}|{ts9wvunV3210/.-,+*hg`H^c\"`_AW\Uyxwvutsrqp]

Try it online!

233556

n/t/roff, 27 bytes.

.de a
\\$1
.if \\$1 .a 1
..

Defines a macro a.

Usage

.a 0
.a 1

Try it online!

233611

Dis, 3 bytes.

}{{

Try it online!

How it works

} ( a=getchar;if a==EOF a=59048;)
 { ( if a==59048 exit; else putchar a%256; )
   { ( again)
( then keep program counter+=1 until 59048 where each cell from i=3 to 59048 is NOP;
   then pc=0 if pc is 59048) 

233636

SNOBOL4 (CSNOBOL4), 109 95 bytes

 n =input
b s =gt(n,1) char(10) ':-' dupl(')',n - 2) s :f(c)
 n =n - 1 :(b)
c output =':' s
end

Try it online!

235246

CLC-INTERCAL, 221 bytes.

DO;1<-#13DO;1SUB#1<-#29DO;1SUB#2<-#1100DO;1SUB#3<-#249DO;1SUB#4<-#255DO;1SUB#5<-#250DO;1SUB#6<-#677DO;1SUB#7<-#373DO;1SUB#8<-#4160DO;1SUB#9<-#570DO;1SUB#10<-#2572DO;1SUB#11<-#225DO;1SUB#12<-#247DO;1SUB#13<-#348DOREADOUT;1

How I generated the code above.

There is other "Hello, World!" program that uses a tail array, but it has 278 bytes when I do these:

I think this is the only site that you can try CLC-INTERCAL online.

Edit. As of 1.-94.-2, politeness is not checked, unlike INTERCAL-72 and CLC-INTERCAL.

235247

CLC-INTERCAL, 116 bytes.

DO;1<-#6DO,1<-#999DOCOMEFROM.1DOWRITEIN;1+,1(91)DO.1<-,1SUB#2(1)DO.2<-.1~#1DDOCOMEFROM.2DO,1SUB#3<-#0(95)DOREADOUT,1

Try it online, although you need to copy and paste!

Assumption

Explaination

DONOTE stores first six characters of line
DO;1<-#6
DONOTE stores rest of characters of line except trailing newline
DO,1<-#999
DONOTE label one
DOCOMEFROM.1
DOWRITEIN;1+,1
DONOTE goto label one if tail one is asterisk
DONOTE first two items of tail one shall be
DONOTE 91 and 95 if space, or
DONOTE 91 and 95 if asterisk
(91)DO.1<-,1SUB#2
DONOTE goto label two if line is not empty
DONOTE obtw every item of tail will be zero
DONOTE if empty line
(1)DO.2<-.1~#1
DONOTE die here
D
DONOTE label two
DOCOMEFROM.2
DONOTE erase the space
DONOTE obtw zeros on tail are ignored
DONOTE when reading out
DONOTE see source code for more info
DO,1SUB#3<-#0
DONOTE goto label 1 after reading out
(95)DOREADOUT,1

235249

Golfing off GIVE UP statements

  1. Trailing GIVE UP statement can be removed, as it will cause E633 error in C-INTERCAL or error 000 or 633 in CLC-INTERCAL to abort.
  2. Replace GIVE UP statements with incomplete statements such as DO or D (D worked on CLC-INTERCAL but not on C-INTERCAL, if without compiler option.).
  3. RETRIVE unSTASHed variable, RESUME #0, and many other runtime errors can also be alternatives.
  4. ABSTAINFROM non-existing labels, invalid labels, etc. Same applied for REINSTATE.

235408

CLC-INTERCAL, 182 bytes.

The following source must be in Latin-1 or ISO-8859-1 encoding:

DO;1<-#1DO.9<-.9/;1SUB#1DOCOMEFROM:9DO.8<-"¥'.8¢:9'"~#1DOWRITEIN;1(1)DO:9<-.9~#16DO.7<-.9~#1DOWRITEIN;1DO.9<-"V'"'¥"'"&'"'¥"#1¢'.9~#4'"'~#1"¢.7'"~#1'¢.8"'~#1"¢#100'"~#5461DOREADOUT;1

Assumed I/O

How to try it online

Try it online! Because of encoding issue, I recommend uploading and submitting the source rather than copying and pasting the code to the form. Also it may take very long time until the program ends.

How to test

Use the following shellscript:

#!/bin/sh
set -eu
cat<<'.' | awk 'BEGIN{ORS=""}$0=(NR>1?"":RS)$0' | iconv -f UTF-8 -t ISO-8859-1 >.i
DO;1<-#1
DO.9<-.9/;1SUB#1
DOCOMEFROM:9
DO.8<-"¥'.8¢:9'"~#1
DOWRITEIN;1
(1)DO:9<-.9~#16

DO.7<-.9~#1
DOWRITEIN;1

DONOTE remove the following long line to uncomment four sentences that begin with "DONOT.9<-" because it will result in timeout because of stupidly long expression.
DONOTE don't worry because they work equivalently.
DO.9<-"V'"'¥"'"&'"'¥"#1¢'.9~#4'"'~#1"¢.7'"~#1'¢.8"'~#1"¢#100'"~#5461

DONOT.9<-.9~#4
DONOT.9<-#1¢.9
DONOT.9<-.¥9~#1
DONOT.9<-"V'"'¥"'"&'".9"¢.7'"~#1'¢.8"'~#1"¢#100'"~#5461

DOREADOUT;1

.
wc -c .i >&2
sick .i
: >o
while read p _ q; do
   o="$(
      printf %s "$p" |
      ./.io |
      tee -a o
      printf X
   )"
   [ "X$o" = "X${q}X" ] &&
      printf "%s: Passed\n" "$p" >&2 ||
      printf "%s: Failed\n" "$p" >&2
done <<'.'
0 -> 0
1 -> 1
0! -> 1
1! -> 1
!0 -> 1
!1 -> 0
!0! -> 0
!1! -> 0
0!! -> 1
1!! -> 1
!!0 -> 0
!!1 -> 1
!0!! -> 0
!!!1 -> 0
!!!0!!!! -> 0
!!!1!!!! -> 0
.
cat o

How it works

DONOTE ;1SUB#1 shall be these:
   '!' is #116
   '0' is #101
   '1' is #100
DONOTE actually first 16 bits are random bits
DONOTE that has at least a 1 bit 
DONOTE when WRITEIN is done
DONOTE then second 16 bits are the values above
DONOTE EOF is really #0
DONOTE otherwise at least 2^16

DO;1<-#1 DONOTE for i/o
DO.9<-.9/;1SUB#1 DONOTE replaces every .9 with ;1SUB#1

DOCOMEFROM:9 DONOTE it is from label 1
DO.8<-"¥'.8¢:9'"~#1 DONOTE for fact
DOWRITEIN;1
(1)DO:9<-.9~#16 DONOTE '!' is #116 others are #101 or #100

DO.7<-.9~#1 DONOTE '0': 1, '1': 0

DOWRITEIN;1 DONOTE has trailing '!'?
DONOTE at this point .9 is '!': #116, EOF: #0, LF: #89

DONOTE explaining long expression

.9~#4                 #1 if .9&0x04==0x04 else #0
'¥"#1¢'...'"'~#1      ^#1
"&'"..."¢.7'"~#1      &.7
'¥"'...'¢.8"'~#1      ^.8
"V'"..."¢#100'"~#5461 |#100


DO.9<-"V'"'¥"'"&'"'¥"#1¢'.9~#4'"'~#1"¢.7'"~#1'¢.8"'~#1"¢#100'"~#5461


DONOTE finally
DOREADOUT;1
```

235419

INTERCAL, 85 bytes Score: 77/85=0.90588, safe.

Input: up to SIX FIVE FIVE THREE FIVE, although actual calcuatable input is smaller than that.

This calculates A000217.

PLEASEWRITEIN.1PLEASE.2<-#1DO(1000)NEXTDO.2<-.3DO(1030)NEXTDO.3<-.3~#65534DOREADOUT.3

Try it online!

The answer

77 bytes.

PLEASEWRITEIN.2PLEASE.1<-.2DO(1020)NEXTDO(1030)NEXTDO.3<-.3~#65534DOREADOUT.3

C-INTERCAL has a subroutine that just increments .1, which is (1020).

Try it online!

235421

INTERCAL, 109 bytes

Wait, no, I don't even need to make a loop.

PLEASE,1<-#11DO,1SUB#1<-#172DO,1SUB#11<-#260PLEASEREADOUT,1DO,1SUB#1<-#252DOREADOUT,1+,1+,1+,1+,1+,1+,1+,1+,1

Try it online!

INTERCAL, 116 bytes

mindoverflow said as if they can't loop shorter, but actually you can. The code below uses .1 as loop counter. Starting with .1<-512, iteration is done with DOCOMEFROM.1~.1 and (1)DO.1<-.1~#1022.

PLEASE,1<-#11DO,1SUB#1<-#172DO,1SUB#11<-#260DO.1<-#512DOCOMEFROM.1~.1PLEASEREADOUT,1DO,1SUB#1<-#252(1)DO.1<-.1~#1022

Try it online!

235422

Calculated COMEFROM, NEXTFROM.

235423

Dividing a variable by two.

DONOTe this is very long. Using C-INTERCAL library.
DO.1<-.9DO.2<-#2DO(1040)NEXTDO.9<-.3
DONOTe shorter way.
DONOTe The number can be smaller if you know that
DONOTe .9 shall have smaller value.
DO.9<-.9~#65534

Similar goes to dividing by 2^n.

235424

Golfing newline output in CLC-INTERCAL

DO,1<-#1DOREADOUT;1+,1

where ;1 is a string to output.

235428

CLC-INTERCAL, 114 bytes.

From this how should I golf off....

DO;1<-#1DO;1SUB#1<-#121DO,1<-#1DO.1<-#512DOCOMEFROM.1~.1DOREADOUT;1+;1+;1+;1+;1+;1+;1+;1+;1+;1+,1(1)DO.1<-.1~#1022

Copy and paste to try it online!

235458

Pxem (don't break loop when items are insufficient), 46 38 bytes, filename only.

It's been a while. As usual, \0001 is not such a string but a character 0x01.

.z.im.a_iH.w.i.c\0001.+.a.s!mexP m'I ,.v.p

Try it online!

With comments

XX.Z
.A.zXX.Z
  # push(getchar())
  .A.iXX.Z
  # constant 'm' charcode
  .AXXm.Z
# break loop if pop==pop
.A.aXX.Z
# "Hi" and dummy
.AXX_iH.Z
# dummy is popped before entering loop
.A.wXX.Z
  # keep pushing until EOF (-1) is met
  .A.i.c\0001.+.aXX.Z
# discard final EOF
.A.sXX.Z
# ", I'm Pxem!"
# reverse stack before printing each item
.A!mexP m'I ,.v.p

235465

CLC-INTERCAL, 85 bytes.

DO;1<-#1DOCOMEFROM#2DOWRITEIN;1(1)DO:1<-;1SUB#1DDOCOMEFROM':1~:1'~#1(2)DOREADOUT;1+;1

Copy and paste to try it online!

With comments, though I don't know its necessity

DONOTE length of array
DO;1<-#1
DOCOMEFROM#2
DONOTE perform getchar() for a time to store to ;1SUB#1
DOWRITEIN;1
DONOTE EOF: zero; otherwise: at least 65536
(1)DO:1<-;1SUB#1
DONOTE die here
D
DONOTE ':1~:1'~#1: zero if EOF one otherwise
DOCOMEFROM':1~:1'~#1
DONOTE putchar() twice
(2)DOREADOUT;1+;1

235469

CLC-INTERCAL, 356 352 bytes.

Assumes adjective and noun has <100 characters.

DO;1<-#3DO;2<-#99DOWRITEIN;1+;2DO;3<-#2DO;3SUB#1<-#29DO;3SUB#2<-#1118DO;4<-#1DO;4SUB#1<-#127DO;6<-#1DO;6SUB#1<-#117DO;5<-#13DO;5SUB#1<-#16DO;5SUB#2<-#368DO;5SUB#3<-#368DO;5SUB#4<-#274DO;5SUB#5<-#103DO;5SUB#6<-#376DO;5SUB#7<-#217DO;5SUB#8<-#374DO;5SUB#9<-#356DO;5SUB#10<-#374DO;5SUB#11<-#375DO;5SUB#12<-#1353DO;5SUB#13<-#276DOREADOUT;3+;2+;4+;6+;1+;6+;5

Copy and paste to try it online!

With comments

DONOTE ;1 for "I'm", ;2 for rest of input
DO;1<-#3
DO;2<-#99
DOWRITEIN;1+;2
DONOTE ;3 for "Hi"
DO;3<-#2DO;3SUB#1<-#29DO;3SUB#2<-#1118
DONOTE ;4 for ","
DO;4<-#1DO;4SUB#1<-#127
DONOTE ;6 for " "
DO;6<-#1DO;6SUB#1<-#117
DONOTE ;5 for "CLC-INTERCAL!"
DO;5<-#13DO;5SUB#1<-#16DO;5SUB#2<-#368DO;5SUB#3<-#368DO;5SUB#4<-#274DO;5SUB#5<-#103DO;5SUB#6<-#376DO;5SUB#7<-#217DO;5SUB#8<-#374DO;5SUB#9<-#356DO;5SUB#10<-#374DO;5SUB#11<-#375DO;5SUB#12<-#1353DO;5SUB#13<-#276
DONOTE concatenate those strings
DOREADOUT;3+;2+;4+;6+;1+;6+;5

235471

INTERCAL, 26 bytes

DOCOMEFROM#1(1)DOREADOUT#0

Try it online!

This works for both C-INTERCAL and CLC-INTERCAL.

235472

Grass, 11 bytes

Taken from original document (Japanese):

wWWwwwwWWww

Try it online!

How it works

In pseudo code:

function f(x){
   Out("w");
   return x(x);
}
f(f)

235573

CLC-INTERCAL (sick) can ABSTAIN and/or REINSTATE non-existing label.

C-INTERCAL (ick), on the other hand, makes it compiler error.

235638

CLC-INTERCAL 1.-94.-2, A001477, safe, score: 16.

Byteset:

@ABDEHIP`abdehip

You may use any i/o method. Also you may use any compiler option.

Try it online! Submitting as CLC-INTRCAL does not let you set compiler option, so you might need to try as shell.

The answer

D`h@I@`P@pAB@d@p`DPb@PD`h@`P@d@aD`h@E@ABPb@P

This is equivalent to DOWRITEIN.1DOREADOUT.1 in Hollerith character set; so input range is OH or ZERO to SIX FIVE FIVE THREE FIVE (inclusive).

Try the following Bash script online:

printf 'D`h@I@`P@pAB@d@p`DPb@PD`h@`P@d@aD`h@E@ABPb@P'>.i;sick -h .i;./.io

How it works

The code can be in Hollerith character set. However, it is implemented incorrectly so the code above is for such behaviour as in implementation, not for documentation.

Here is the script to accept punch lines to generate a program in Hollerith.

Also why doesn't the compiler guess anything other than ASCII? So I had to force it to use my intended character code, by -h.

See also

My answer on Print X without X

235659

CLC-INTERCAL, 108 bytes.

DO;1<-#1DO;1SUB#1<-#117DO;2<-#1DOCOMEFROM#9DOWRITEIN;2(1)DO:1<-;2SUB#1DDOCOMEFROM':1~:1'~#1(9)DOREADOUT;2+;1

Copy and paste to try it online!

How it works

DONOTE ;1 has " "
DONOTE ;2 shall accept a character
DO;1<-#1
DO;1SUB#1<-#117
DO;2<-#1

DOCOMEFROM#9
  DOWRITEIN;2
  DONOTE if EOF, then :1 will be #0
  DONOTE otherwise it's at least #65536
  (1)DO:1<-;2SUB#1
  DONOTE error exit here
  D
  DONOTE come here if not EOF
  DOCOMEFROM':1~:1'~#1
(9)DOREADOUT;2+;1
```

235660

CLC-INTERCAL, 82 bytes.

DO;2<-#1DOCOMEFROM#9DOWRITEIN;2(1)DO:1<-;2SUB#1DDOCOMEFROM':1~:1'~#1(9)DOREADOUT;2

Copy and paste to try it online!

How it works

DONOTE it shall have at most one byte
DO;2<-#1

DOCOMEFROM#9
   DONOTE similar to getchar() but not really
   DOWRITEIN;2
   DONOTE checks if EOF
   (1)DO:1<-;2SUB#1
   DONOTE error exit
   D
   DONOTE come here unless EOF
   DOCOMEFROM':1~:1'~#1
   DONOTE no need to modify the array before outputting
   (9)DOREADOUT;2

How I/O works in CLC-INTERCAL

235672

CLC-INTERCAL 1.-98.-2, 198 bytes, safe.

33 bytes are revealed:

__#3__#9__,1_____________________________3__3__-_3__3__________-_33_D_______&_________-_____________-___D_#4__#28D______________-________B#__-_V________________-_V_______________________________U___

Output is:

!->Ma

Should I post shorter one next time?

Try it online!

Answer

Sorry for irrationally difficult problem.

DO#3<-#9DO,1<-#3DO,1SUB#3<-#3~#3DO,1SUB'#3~#3'<-#3~#3DO,1SUB#5<-#338DO,1SUB"&'#3~#3'"<-#27DO,1SUB#4<-#27DO#4<-#28DO,1SUB'#4~#4'<-#4DO,1SUB#6<-"V'#V4'"DO,1SUB#8<-'V"V'#V4'"'DO,1SUB#2<-#333DOREADOUT,1

How it works

DO#3<-#9 changes meaning of the constant.

DO,1<-#3 lets array to have nine item; note previous statement.

DO,1SUB#3<-#3~#3 is equivalent to DO,1SUB#9<-#9~#9, which is equivalent to DO,1SUB#9<-#3.

DO,1SUB'#3~#3'<-#3~#3 does ,1SUB#3<-#3.

DO,1SUB#5<-#338 is equal to DO,1SUB#5<-#18 when READing OUT; this is how Baudot character set works; it cares for only lower five octets.

DO,1SUB"&'#3~#3'"<-#27 does ,1SUB#1<-#27.

DO,1SUB#4<-#27 is obvious, as none of those constants are not overloaded yet.

DO#4<-#28 now overloads the operand.

DO,1SUB'#4~#4'<-#4 now does ,1SUB#7<-#28.

DO,1SUB#6<-"V'#V4'" is actually DO,1SUB#6<-#30.

DO,1SUB#8<-'V"V'#V4'"' does ,1SUB#8<-#31

DO,1SUB#2<-#333 does what it says.

Finally, output is done by DOREADOUT,1.

By the way the reason why an array requires 9 items to output 5 characters is: tail arrays adopt extended Baudot character set. The character set has a concept of "state": uppercase, lowercase, figures, and symbols. When a same value is READ OUT with different state, the different character is READ OUT

235683

INTERCAL, 39 bytes

Domain is ZERO or OH to FOUR TWO NINE FOUR NINE SIX SEVEN TWO NINE FIVE. _ (zero) for even and I (one) for odd. Also works in CLC-INTERCAL.

DOWRITEIN:1DO:1<-':1~#1'PLEASEREADOUT:1

Try it online!

235685

INTERCAL (C-INTERCAL), 303 236 229 bytes

  1. Forgot one more PLEASEDO to replace with PLEASE.
  2. Also .2<-.4~#255 to .2<-.4.
DO,1<-#1DOCOMEFROM#3DOWRITEIN,1(1)DO.1<-,1SUB#1DO.2<-.4DO(1000)NEXTDO.4<-.3PLEASE.3<-!3~#15'$!3~#240'DO.3<-!3~#15'$!3~#240'DO.2<-!3~#15'$!3~#240'PLEASE.1<-.5DO(1010)NEXTDO.5<-.2DO,1SUB#1<-.3(3)PLEASEREADOUT,1PLEASECOMEFROM.1~#256

Try it online!

Previous

Seeing original code, I noticed that program should end when .1 (,1SUB#1) has #256, so I erased some NEXT and RESUME statements to replace with (1)DO.1<-... and PLEASECOMEFROM.1~#256. It works, even the expression .1~#256 evaluates to zero when not reached to EOF. Additionally, replacing .1 with ',1SUB#1' worked; this is opposed to CLC-INTERCAL. This is really a golfing tip.

Also I almost forgot that every variable is initialized with zero.

DO,1<-#1DOCOMEFROM#3DOWRITEIN,1(1)DO.1<-,1SUB#1DO.2<-.4DO(1000)NEXTDO.4<-.3~#255PLEASEDO.3<-!3~#15'$!3~#240'DO.3<-!3~#15'$!3~#240'DO.2<-!3~#15'$!3~#240'PLEASE.1<-.5DO(1010)NEXTDO.5<-.2DO,1SUB#1<-.3(3)PLEASEREADOUT,1PLEASECOMEFROM.1~#256

Try it online!

Prev.: 303 bytes.

Yesterday I showed you making a short cat program in CLC-INTERCAL is easy; but it's not really in C-INTERCAL, due to its I/O system.

The following program originates Louis Howell's; I reduced the code for this golf problem. This seemed to be the shortest one that satisfies politeness check.

DO,1<-#1DO.4<-#0DO.5<-#0DOCOMEFROM#3DOWRITEIN,1DO.1<-,1SUB#1DO(1)NEXTDO_(2)PLEASERESUME'?.1$#256'~'#256$#256'(1)DO(2)NEXTDOFORGET#1PLEASE.2<-.4DO(1000)NEXTDO.4<-.3~#255PLEASEDO.3<-!3~#15'$!3~#240'DO.3<-!3~#15'$!3~#240'DO.2<-!3~#15'$!3~#240'PLEASE.1<-.5DO(1010)NEXTDO.5<-.2DO,1SUB#1<-.3(3)PLEASEREADOUT,1

Try it online!

235689

INTERCAL (C-INTERCAL), 229 bytes

This version accepts any integers, in decimal (e.g. -156); requires to be terminated with EOF.

Outputs _ for even and I for odd.

DO,1<-#1DOCOMEFROM#3DOWRITEIN,1(1)DO.1<-,1SUB#1DO.2<-.4DO(1000)NEXTDO.4<-.3PLEASE.3<-!3~#15'$!3~#240'DO.3<-!3~#15'$!3~#240'DO.2<-!3~#15'$!3~#240'PLEASE.1<-.5DO(1010)NEXT(3)DO.5<-.2PLEASECOMEFROM.1~#256DO.2<-.2~#128PLEASEREADOUT.2

Try it online!

How it works

235691

CLC-INTERCAL, score: 7, safe.

For clarification here is a sequence of seven octets to output in hex:

52 45 41 44 4f 55 54

Try it online!

The answer

Here is od -t x1 -v of source:

0000000 c4 d6 5e f1 4c 60 7b f7 c4 d6 5e f1 e2 e4 c2 7b
0000020 f1 4c 60 7b f1 c4 d6 5e f1 e2 e4 c2 7b f2 4c 60
0000040 7b f3 f6 f8 c4 d6 5e f1 e2 e4 c2 7b f3 4c 60 7b
0000060 f3 f7 f5 c4 d6 5e f1 e2 e4 c2 7b f4 4c 60 7b f1
0000100 f3 f6 f9 c4 d6 5e f1 e2 e4 c2 7b f5 4c 60 7b f1
0000120 f3 f5 f4 c4 d6 5e f1 e2 e4 c2 7b f6 4c 60 7b f5
0000140 f6 f6 c4 d6 5e f1 e2 e4 c2 7b f7 4c 60 7b f2 f5
0000160 f3 c4 d6 d9 c5 c1 c4 d6 e4 e3 5e f1
0000174

It's:

DO;1<-#7DO;1SUB#1<-#1DO;1SUB#2<-#368DO;1SUB#3<-#375DO;1SUB#4<-#1369DO;1SUB#5<-#1354DO;1SUB#6<-#566DO;1SUB#7<-#253DOREADOUT;1

in EBCDIC.

You may need compiler option -e, as character set guessing does not work.

See also

My answer on Restricted mini challenge

235785

Pure Bash, 13 bytes, sequence A010888, cracked (17 bytes).

I think this is an easy problem.

x=
echo ${#x}

I've hidden an 18 bytes of string.

Try it online!

Intended solution

Insert the following string between first and second lines:

x=x${x#xxxxxxxxx}

235834

BrainCrash, 43 22 bytes.

^^+++++++++++.>>[.<.>]

I'll golf off later.

Try it online!

235904

SNOBOL4 (CSNOBOL4), 43 bytes

Outputs two trailing LFs.

 output =dupl(dupl('*',10) char(10),10)
end

Try it online!

235905

CLC-INTERCAL, 67 bytes.

Outputs 1#D. It was difficult to adjest program length. Eventually I decided to do \#9; this caused no side effects.

DO;1<-#9\#9DO;1SUB#1<-#100DO;1SUB#2<-#374DO;1SUB#3<-#276DOREADOUT;1

Copy and paste to try it online!

235906

FerNANDo, 381 bytes

Outputting language name as ferNANDo, as in esolang page title.

0 A S D F G H J K
0 Q W E R T Y U I
1 0 1 1 0 1 1 0 1
0 1 0 0 1 0 0 0
0 1 1 0 1 0 0 1
? a b c d e f g h
?
a b c d e f g h
? a b c d e f g h
?
0 0 1 0 1 1 0 0
0 0 1 0 0 0 0 0
A S D F G H J K
Q W E R T Y U I
0 1 1 0 1 1 0 1
0 0 1 0 0 0 0 0
0 1 1 0 0 1 1 0
0 1 1 0 0 1 0 1
0 1 1 1 0 0 1 0
0 1 0 0 1 1 1 0
0 1 0 0 0 0 0 1
0 1 0 0 1 1 1 0
0 1 0 0 0 1 0 0
0 1 1 0 1 1 1 1
0 0 1 0 0 0 0 1

Try it online!

How it works

# accepts I
0 A S D F G H J K
# accepts '
0 Q W E R T Y U I
# accepts m
1 0 1 1 0 1 1 0 1
# outputs H
0 1 0 0 1 0 0 0
# outputs i
0 1 1 0 1 0 0 1
# cat begins
? a b c d e f g h
?
a b c d e f g h
? a b c d e f g h
?
# cat ends
# outputs rest
# characters .
0 0 1 0 1 1 0 0
0 0 1 0 0 0 0 0
A S D F G H J K
Q W E R T Y U I
0 1 1 0 1 1 0 1
0 0 1 0 0 0 0 0
0 1 1 0 0 1 1 0
0 1 1 0 0 1 0 1
0 1 1 1 0 0 1 0
0 1 0 0 1 1 1 0
0 1 0 0 0 0 0 1
0 1 0 0 1 1 1 0
0 1 0 0 0 1 0 0
0 1 1 0 1 1 1 1
0 0 1 0 0 0 0 1

235907

FerNANDo, 53 bytes

Outputs aaa, but is it accepted...?

a a a
z a a z z z z a
z a a z z z z a
z a a z z z z a

Try it online!

235909

Malbolge, 67 bytes

Outputs n D. Eventually I thought a space is really necessary.

D'`_$"\\[||98V6Bu@tOq<.'98*ZjE&fe {Ab~,v*)]xZvonsl2ponmfN+cba`ed]#n

Try it online!

235934

CLC-INTERCAL, 38 bytes, safe.

This is much easier than previous. Six bytes are revealed:

____<-___________<-________DO_________

Outputs:

BCDLX

Try it online!

The answer

DO;1<-#1DO;1SUB#1<-#17DOREADOUT;1+#460

Please note output is "B" and "CDLX".

236048

INTERCAL (C-INTERCAL), 61 bytes

DO,1<-#9DO,1SUB#1<-#126DOCOMEFROM#9PLEASEREADOUT,1(9)DO,1<-#9

Try it online!

236049

CLC-INTERCAL, 48 bytes.

DO;1<-#1DO;1SUB#1<-#20DOCOMEFROM#9(9)DOREADOUT;1

(Don't) Copy and paste to try it online! It is very recommend to replace COME with NEXT, as output suppression may be weak.

236184

CLC-INTERCAL, A001477, safe, score: 14.

Byteset:

ACFGIJLPRWX[\_

Rules

Answer

IXRJFPAFL[\W_IXJACIXGP[\W

This is DOWRITEIN.1DOREADOUT.1 in Baudot encoding, so input range is OH or ZERO to SIX FIVE FIVE THREE FIVE. Due to the encoding, you need compiler option -b if it is newer so the character guessing does not work.

Try the following Bash script in online environment

printf %s 'IXRJFPAFL[\W_IXJACIXGP[\W'>.i
sick -b .i
./.io<<<'THREE FOUR FIVE'

Copy and paste to try it online!

See also

236461

CLC-INTERCAL 1.-94 does not check politeness of the program.

So every PLEASE and PLEASEDO can be replaced with DO.

236614

SNOBOL4 (CSNOBOL4), 19 bytes

 output =99 ^ 9
end

Outputs:

913517247483640899

Try it online!

236615

INTERCAL, 12 bytes

DOREADOUT#81

Outputs:

     
LXXXI

Try it online!

236678

SNOBOL4 (CSNOBOL4), 19 bytes

 output =date()
end

Are there any other ways to obtain a random value in this language?

Try it online!

237156

Pure Bash, 32 + 1 = 33 bytes

The 1-byte penalty is for filename specification; the following program must be saved as x.

((x))||read x
echo $x
((x))&&. x

Try it online!

Tracing how it works

237157

Pure Bash, 70 bytes 69 bytes 68 bytes 63 + 1 = 64 bytes

The following program must be saved as x, which is for 1 byte of penalty.

''
((++x%3))||Fizz
((x%5))||$_\Buzz
echo ${_:-$x}
((x>99))||. x

Try it online!

237158

Pure Bash, 32 + 1 = 33 bytes

One additional byte for filename specification: x.

echo "$2
$1"
shift 2
(($#))&&. x

Try it online!

Usage


Pure Bash, 34 + 1 = 35 bytes

One additional byte for filename specification: x.

read x
read y||>x
echo "$y
$x"
. x

Try it online!

Usage

237161

In Pure Bash (or any other pure shellscript), use . for looping.

For example, if you want to display each value of 1^2, 2^2, 3^2, ..., 999^2, 1000^2,

echo $[++x*x]
((x>999))||. x

(where filename is x) is shorter than

for((;x++<1000;));{
echo $[x*x]
}

Try it online!

237164

Pure Bash, 34 + 1 = 35 bytes

Filename must be x; this is for extra one byte.

echo $[x++]
a=x
((x>${#a}00))||. x

Try it online!

237165

Pure Bash, 42 + 1 = 43 bytes

Filename must be x; it is for extra one byte.

read x||>x
((1${x:6:1}1))||echo ${x:7}
. x

Try it online!

Usage

237273

CLC-INTERCAL, 95 67 bytes.

Why does CLC-INTERCAL 1.-94.-2 lack !1~.1'? I could have golfed off one byte.

DOCOMEFROM#9(1)DOWRITEIN.1+.2DDOCOMEFROM'.1~.1'~#1(9)DOREADOUT.2+.1

Copy and paste to try it online!

Usage

Try these inputs

ONE
TWO
ONE
TWO
ZERO
ONE
TWO
THREE
FOUR
FIVE
SIX
ZERO

237274

Pxem, 18 + 0 = 18 bytes.

The configure is:

Filename:

.w._._.n .o.n .o.a

Content is empty.

Try it online!

Usage

237315

UTF-9 was an April Fool's Day RFC joke specifications for encoding Unicode suitable for 9-bit nonet platforms.

Challenge

Your task is to implement a program or a function or a subroutine that takes one integer, who represents the codepoint of a character, to return a sequence of integers that represents its corresponding UTF-9 value.

Definition of UTF-9

In this problem, the definition of the UTF-9 shall be as follows:

From section 3 of RFC 4042:

A UTF-9 stream represents [ISO-10646] codepoints using 9 bit nonets. The low order 8-bits of a nonet is an octet, and the high order bit indicates continuation.

UTF-9 does not use surrogates; consequently a UTF-16 value must be transformed into the UCS-4 equivalent, and U+D800 - U+DBFF are never transmitted in UTF-9.

Octets of the [UNICODE] codepoint value are then copied into successive UTF-9 nonets, starting with the most-significant non-zero octet. All but the least significant octet have the continuation bit set in the associated nonet.

Constraints

Input is nonnegative integers that is defined on Unicode: which is 0 to 0x7FFFFFFF (inclusive)

Rules

Test cases

Leftmost column: Input in hexadecimal.

Right items: output as a sequence of octed integers.

0000     000
0041     101
00c0     300
0391     403 221
611b     541 033
10330    401 403 060
e0041    416 400 101
10fffd   420 777 375
345ecf1b 464 536 717 033

Hint Notes

Section 5.2 of RFC4042 has an example of the impmenentation.

Here is a non-competing Python function that represents the algorithm:

def ucs4utf9(x:int)->[int]:
 l=[]
 if x>0x100:
  if x>0x10000:
   if x>0x1000000:
    l.append(0x100|(x>>24)&0xff)
   l.append(0x100|(x>>16)&0xff)
  l.append(0x100|(x>>8)&0xff)
 l.append(x&0xff)
 return l

Test it online!

Those two programs were incorrect, as they convert codepoints 0x100, 0x10000, and 0x1000000 incorrectly; they should be converted to 257,0, 257,256,0, 257,256,256,0 respectively.

237320

INTERCAL, 164 162 154 bytes

I made this program before noticing the first comment of the OP. In my comment section the two example programs on both RFC document and my Python implementation says values 0x100, 0x10000, and 0x1000000 are converted incorrectly, while this program converts 256 to [257,0]; which seems to be correct.

DOWRITEIN:1DOCOMEFROM.3PLEASE.1<-!2$:1~#255'~#54613DOSTASH.1DO.2<-#128PLEASE:1<-:1~#65520$#65520(1)DO.3<-':1~:1'~#1(9)DORETRIEVE.1DOREADOUT.1PLEASE(9)NEXT

Try it online!

Usage

Ungolfed

DOWRITEIN:1

DONOTE from label (1) if .3 got at least one bit of one
DOCOMEFROM.3
DONOTE :1~#255 is done first on CLCI
PLEASENOTE obtain lowest 8 bits
DONOTE then do C operation such twospot[1]|spot[2]
DONOTE spot[2] is 256 if second time to visit here 0 otherwise
PLEASE.1<-!2$:1~#255'~#54613
PLEASENOTE this and RETRIEVE statements below
DOSTASH.1
DO.2<-#128
DONOTE like (twospot[1]>>8)
PLEASE:1<-:1~#65520$#65520
(1)DO.3<-':1~:1'~#1

PLEASENOTE finally, until no more .1 stacks
(9)DORETRIEVE.1
DOREADOUT.1
PLEASE(9)NEXT

Algorithm

  1. Write in to the codepoint.
  2. Make a list from backward, using STASH and RETRIEVE statements and a stack.
  3. Then output each item.

237349

INTERCAL, 41 bytes

Based on answer by @unrelatedstring. If you don't care for errors, won't you guys golf off the program easily?

DOWRITEIN.1DOCOMEFROM.1(1)PLEASEREADOUT.1

Try it online!

237351

FIM++, 87 bytes

I golfed off one byte: the original was by @martinender. I golfed off a space between a token said and a symbol ".

Dear Princess Celestia:A.Today I learned:I said"Hello, World!".Your faithful student,B.

Try it online!

237488

Know grep options

See also man 1p grep and manual for GNU Grep.

grep -x foo is equivalent to grep '^foo$

This is POSIX-compatible.

Consider only input lines that use all characters in the line excluding the terminating <newline> to match an entire fixed string or regular expression to be matching lines.

For example, the following two are equal:

grep -E '^abc$|^def$'
grep -F -x 'abc
def'

237526

UTF-1 is one of the methods to transform ISO/IEC 10646 and Unicode into a sequence of bytes. It was originally for ISO 10646.

The UTF-1 encodes every character with variable length of byte sequence, just like UTF-8 does. It was designed to avoid control codes. But it was not designed to avoid duplication of a slash character ('/'), which is path delimiter for many operating systems. Additionally it takes a bit long to process the algorithm, because it is based on modulo 190, which is not power of two. Eventually UTF-8 was better than that.

In this challenge we are reviving UTF-1.

How it works

Every constant value in tables on this section is represented in hexadecimal value.

The symbol / is the integer division operator, % is the integer modulo operator, and ^ means power. The precedence of operators is ^ first, / second, % third, and others last. Here is how to convert each codepoint to UTF-1 (sorry for typo last time):

codepoint x UTF-1
U+0000 to U+009F (x)
U+00A0 to U+00FF (A0,x)
U+0100 to U+4015 y=x-100 in (A1+y/BE,T(y%BE))
U+4016 to U+38E2D y=x-4016 in (F6+y/BE^2,T(y/BE%BE),T(y%BE))
U+38E2E to U+7FFFFFFF y=x-38E2E in (FC+y/BE^4,T(y/BE^3%BE),T(y/BE^2%BE),T(y/BE%BE),T(y%BE))

T(z) is a function such that:

z T(z)
0 to 5D z+21
5E to BD z+42
BE to DE z-BE
DF to FF z-60

Challenge

Your task is to implement a program or a function or a subroutine that takes one integer, who represents the codepoint of a character, to return a sequence of integers that represents its corresponding UTF-1 value.

Constraints

Input shall be an nonnegative integer up to 0x7FFFFFFF.

Rules

Test cases

Taken from the Wikipedia article.

    U+007F  7F
    U+0080  80
    U+009F  9F
    U+00A0  A0 A0
    U+00BF  A0 BF
    U+00C0  A0 C0
    U+00FF  A0 FF
    U+0100  A1 21
    U+015D  A1 7E
    U+015E  A1 A0
    U+01BD  A1 FF
    U+01BE  A2 21
    U+07FF  AA 72
    U+0800  AA 73
    U+0FFF  B5 48
    U+1000  B5 49
    U+4015  F5 FF
    U+4016  F6 21 21
    U+D7FF  F7 2F C3
    U+E000  F7 3A 79
    U+F8FF  F7 5C 3C
    U+FDD0  F7 62 BA
    U+FDEF  F7 62 D9
    U+FEFF  F7 64 4C
    U+FFFD  F7 65 AD
    U+FFFE  F7 65 AE
    U+FFFF  F7 65 AF
   U+10000  F7 65 B0
   U+38E2D  FB FF FF
   U+38E2E  FC 21 21 21 21
   U+FFFFF  FC 21 37 B2 7A
  U+100000  FC 21 37 B2 7B
  U+10FFFF  FC 21 39 6E 6C
U+7FFFFFFF  FD BD 2B B9 40

237598

CLC-INTERCAL, 144 bytes.

In ISO-8859-1:

DO,1<-#99DOWRITEIN,1DO;1<-#2DO;1SUB#1<-#52DO;1SUB#2<-#360(1)DO.1<-',1SUB#3'~#31(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬xDO;1SUB#2<-#0DOCOMEFROM.1DOREADOUT;1

Usage

Copy and paste the following Bash script to test online on shinh's server!

printf %s "$(cat<<'x'
DO,1<-#99DOWRITEIN,1DO;1<-#2DO;1SUB#1<-#52DO;1SUB#2<-#360(1)DO.1<-',1SUB#3'~#31(3)DO¬x(6)DO¬x(7)DO¬x(24)DO¬xDO;1SUB#2<-#0DOCOMEFROM.1DOREADOUT;1
x
)" | iconv -f UTF-8 -t LATIN1 >x.i
wc -c x.i
sick x.i
while IFS=: read x _; do
echo $x
./x.io <<<$x
echo
done<<'x'
airplane: an
water: a
snake: a
hybrid: a
igloo: an
WATER: a
IglOO: an
HoUr: a
unIverSe: an
youTH: a
x

How it works

The idea was just to make "an" on the variable ;1 and then erase "n" unless vowel. I used Baudot character set for input.