Convert C header names to C++ header names

Question

In the C standard library, header names end with a .h suffix:

stdio.h

In C++, those header names are available in an alternative form, with a c prefix instead:

cstdio

Write a function that converts the first form into the second. You can do the conversion in-place, or leave the original string intact and return a new string. Whatever feelds natural in your language of choice.

The code must be compiled/interpreted without errors. Compiler warnings are acceptable.

Here is your baseline C solution. It has 70 characters and generates a warning about strlen:

void f(char*h){int i=strlen(h);h[--i]=0;while(--i)h[i]=h[i-1];*h='c';}

The shortest solution (measured in number of characters) wins.

Update: If your language of choice does not support functions, whole programs are also acceptable.

Update: As suggested by FUZxxl, here is a complete list of the header files in the C standard library:

assert.h
ctype.h
errno.h
float.h
limits.h
locale.h
math.h
setjmp.h
signal.h
stdarg.h
stddef.h
stdio.h
stdlib.h
string.h
time.h

Specifically, there are no header names with multiple dots in them.

Answer 1

80386 machine code, 13 bytes

Hexdump of the code:

b0 63 86 01 41 3c 2e 75 f9 c6 01 00 c3

Source code (can be compiled by Visual Studio):

__declspec(naked) void __fastcall conv(char s[])
{
    _asm {
        mov al, 'c';            // b0 63
    myloop:
        xchg al, [ecx];         // 86 01
        inc ecx;                // 41
        cmp al, '.';            // 3c 2e
        jne myloop;             // 75 f9
        mov byte ptr [ecx], 0;  // c6 01 00
        ret;                    // c3
    }
}

It converts the string in-place. The code is so simple, it doesn't need to save and restore registers (using only al and ecx, which the fastcall convention allows to clobber).

Answer 2

Python: 19 characters

lambda s:'c'+s[:-2]

Answer 3

CJam, 6 bytes

'clW(<

This is a full program which reads the string via STDIN

Explanation:

'c               "Put character c on stack";
  l              "Read a line from STDIN";
   W             "W is a predefined variable with value -1";
    (            "Decrease the value by 1";
     <           "Remove last 2 characters from the string on stack, the input argument";

Try it online here

Answer 4

Java 8 — 25 characters

h->"c"+h.replace(".h","")

Answer 5

brainfuck - 25 23 bytes

,[>,]<-----.<,<[<]>[.>]

If your language of choice does not support functions, whole programs are also acceptable.

This is a whole program that takes input from STDIN.

,[>,]      get all bytes of input
<-----.    subtract 5 from last byte (always "h"; "h" minus 5 = "c") and print result
<,         set second last byte to 0 by abusing comma
<[<]>      go to first byte
[.>]       print byte and move right until hitting 0

Answer 6

Haskell — 23 characters

('c':).takeWhile(/='.')

Haskell — 16 characters, as suggested by nimi

('c':).init.init

Answer 7

C, 38

See on Ideone

f(s,o){snprintf(o,strlen(s),"c%s",s);}

s is a pointer to the input string, and o is where the output should be written to.

I found a way to abuse snprintf. The output string conveniently happens to be one character shorter than the input, and the maximum length of the string written by snprintf is 1 less than the n argument, so it cuts off the .h. Note: this technique will not work with Microsoft's implementation because it does the wrong thing and fails to null-terminate the string.

Answer 8

Windows Batch file 11

@echo c%~n1

The first parameter passed in is %1. The ~n modifier returns just the filename without extension.

If it's acceptable to echo the expanded command to the screen as well, then the initial @ could be removed.

Answer 9

TIS Node Type T21 Architecture - 85 bytes

This answer is just for fun; the language came into existence after this challenge was written and I therefore cannot win with it. (Not that I was going to.)

Okay, I had a little fun with this one. I probably should just call the language "TIS-100", but why break character? :D

TIS-100 is a game about programming a computer with a totally unique and bizarre architecture. I wrote a custom puzzle for this challenge, which allows me to take input and check output against a known-correct "string". Unfortunately, there's no way to handle strings or characters, so this program simply uses the ASCII value of each character for input and output.

If you'd like to see it in action, you can use this emulator, or just watch me run it in the actual game here. Note that in the video, the final line of the first node is D:MOV UP NIL. After finishing the video, I realized I could golf that down to D:ADD UP. Functionally there's no difference, because the value of ACC is immediately overwritten anyway.

This is the string I used for my byte count:

MOV 99 ANY
MOV -46 ACC
ADD UP
JEZ D
ADD ACC ANY
JRO -5
D:ADD UP
MOV UP ANY
MOV UP ANY

That's the text of each non-empty node, seperated by newlines (effectively adding 1 byte for each node used beyond the first, mirroring our rule about code in multiple files).

Answer 10

J (9 characters)

'c',_2}.]

• |y is the magnitude of y (also called absolute value)
• x }. y drops |x items from y; items are dropped from the front if x is positive, from the end if x is negative.
• x , y appends x and y.
• 'c' , _2 }. y does the transformation you want; in tacit notation this can be expressed as 'c' , _2 }. ].

Answer 11

Dyalog APL (8 characters)

'c',¯2↓⊢

This solution is exactly the same as the J solution I submitted but uses one character less due to ↓ being one character less than }..

Answer 12

piet (9x11 = 99 8X11=88)

another try (2x37 = 74)

Hard to make it much smaller since it needs to generate a 99 ('c') and a 46('.'), and that takes space in piet.

Answer 13

Ostrich 0.6.0, 8 characters

););"c\+

) is the "right uncons" operator. When applied to a string, it turns, for example, `foo` into `fo` `o`. ; is used to pop the extra character off, and this is done again.

Then, "c is pushed. This is simply a shorthand for `c`.

\+ swaps the top two stack elements and concatenates them.

Answer 14

F# - 39 37 31

31 - Because typeinference in F# rocks!

fun s->("c"+s).Replace(".h","")

37

fun(s:string)->"c"+s.Replace(".h","")

39

fun(s:string)->"c"+s.Remove(s.Length-2)

Answer 15

gema, 6

*.h=c*

(Gema is an obscure macro language.)

Answer 16

Bash, 18

f()(echo c${1%.*})

Output:

$ f stdio.h
cstdio
$ 

Answer 17

GNU sed -r, 14

sed doesn't really have any concept of functions, so here is a complete sed program instead:

s/(.*)../c\1/

Output

$ sed -r 's/(.*)../c\1/' <<< stdio.h
cstdio
$ 

The -r has been included in the score as one extra character.

Answer 18

Pyth, 7 characters

L+\cPPb

Explanation:

L         def y(b):return
 +\c                      "c" +
    PPb                         b[:-1][:-1]

Try this:

L+\cPPb
y"stdio.h

on the online Pyth Compiler/Executor

---

If full programs were allowed:

Pyth, 6 characters

+\cPPQ

Answer 19

Prelude, 31 characters

Since full program submissions are apparently acceptable, here is a program that reads the C-style header from STDIN and prints the C++-style header to STDOUT:

99+9+(?)###(#
9(1-)       ^)(!)

This requires a standard-compliant interpreter which prints output as character codes. If you're using the Python interpreter you'll need to set NUMERIC_OUTPUT = False.

It also requires that there's no trailing newline on STDIN.

Explanation

In Prelude all lines are executed in parallel, one column at a time. Each line has its own stack, initialised to an infinite amount of 0s.

99+9+
9(1-)

This is the shortest I could come up with to get a 99 onto the top stack (the character code of c). First I add up 18 on the top stack and push a 9 onto the bottom stack. The bottom then counts down to 0 in a loop, while the top stack adds more 9s up. This adds up to 99 on the top stack, and the bottom stack is left with 0s again. Note that all of +9+ is part of the loop, so there are actually two addition operations per iteration, but that's not an issue, thanks to the infinite supply of 0s underneath.

Now (?) reads STDIN, one character at a time and pushes onto the top stack. The loop terminates at the end of the input, when ? pushes a zero. ### gets rid of that zero, the h and the .. Now the next loop pops numbers from the top stack while copying them to the bottom stack. This essentially reverses the stack. Note that the opening and closing parentheses are on different lines - this is not an issue, because the vertical position of the ) is irrelevant in Prelude, but it saves me a byte on the first line.

Lastly, (!) prints all the characters until the stack is empty.

Answer 20

C++14, 41 characters

[](auto&s){s="c"+s.substr(0,s.size()-2);}

Inspired by this other answer. I made it a separate answer because here I use a feature that is new in c++14, generic lambda.

See it in action here.

Answer 21

Perl — 20 characters

sub{c.pop=~s/..$//r}

Note how c is a bareword and as such this requires a lack of use strict. This must be used as an expression, not a statement.

Answer 22

T-SQL — 58 characters

CREATE PROC Q(@ VARCHAR(MAX))AS
SELECT'c'+LEFT(@,LEN(@)-2)

Run as EXEC Q (your string here)

Answer 23

C, 64

Mildly shorter than the c reference:

f(char*h){char*d=strstr(h,".");memmove(h+1,h,d++-h);*d=0;*h=99;}

Probably more golfing to be done with this.

---

C, 48 (libc hack)

f(char*h){strcpy(h+1,h);*strstr(h,".")=0;*h=99;}

The strcpy manpage explicitly states "The strings may not overlap". However I found that the libc I am using appears to be coded safely to handle this correctly all the same. This is GNU C Library (Ubuntu EGLIBC 2.19-0ubuntu6.4) on Ubuntu 14.04.

Answer 24

Marbelous, 24

@063
-Z//
3W<C+Z
]]!!
@0

Takes input through STDIN, outputs to STDOUT.

This works by checking each byte with . (0x46). As 0x46 cannot fit inside a single base-36 digit, we subtract 35 (Z) before comparing, and add it back before outputting.

Each marble is duplicated by 3W (three-way duplicator, but the left side is discarded off the side of the board). The marble sent downwards fetches the next byte from STDIN. The marble to the right is checked to ., then either outputted, or sent to !!, which terminates the program.

The program starts by passing c (0x63) through, which will be output to STDOUT.

Try it online here. Libraries must be enabled, cylindrical boards must be disabled.

Answer 25

JavaScript (ES6) 20

Can't believe ES6 was still missing

s=>'c'+s.slice(0,-2)

Answer 26

Perl, 15 (14 + -p)

s/(.*)\.h/c$1/

Answer 27

mk, 34 characters

mk(1) is the Plan 9 replacement for make. Just for fun, this mkfile converts C header names into C++ header names:

c%:Q:
    :

%.h:Q: c%
    echo $prereq

There is a single tab before : and echo. Use like this:

% mk stdio.h
cstdio

Answer 28

Excel formula, 36 bytes

If the header is put in cell A1,

=CONCATENATE("c",LEFT(A1,LEN(A1)-2))

Explanation

=CONCATENATE("c",LEFT(A1,LEN(A1)-2))
=CONCATENATE(   ,                  )  Adds two strings
             "c",                     The letter 'c'
                 LEFT(            )   Returns the specified # of chars from the beginning
                      A1,             Cell A1
                         LEN(A1)-2    The length of A1, minus 2 from the '.h'

Answer 29

Japt, 7 6 bytes

ic ¯-2
ic     # Given the default input, prepend a 'c' at the start
   ¯-2 # and trim off the last two letters.

Try it online!

Answer 30

Whitespace, 63 bytes

[S S S T    T   S S S T T   N
_Push_99_c][T   N
S S _Print_as_character][N
S S N
_Create_Label_LOOP][S S S N
S_Push_0][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S N
S _Duplicate][S S S T   S T T   T   S N
_Push_46_.][T   S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_EXIT][T N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Explanation in pseudo-code:

Print "c"
Start LOOP
  Character i = STDIN as character
  if(i == '.')
    EXIT program (with error)
  Print i
  Go to next iteration of LOOP

Program stops with an error: Label_EXIT not found.

Answer 31

CoffeeScript - 16

(x)->"c"+x[..-3]

Answer 32

TI-BASIC 83/84, 15

"c"+sub(Ans,1,length(Ans)-2

Answer 33

Ruby: 16 characters

->x{?c+x[0..-3]}

Or, more correct solution as suggested by @mbuettner

->x{?c+x[/\w+/]}

You can call it like this:

->x{?c+x[/\w+/]}.call 'stdio.h'
# cstdio

Answer 34

R, 33

function(x)sub("(.+)..","c\\1",x)

This function uses regular expressions.

Example usage:

> (function(x)sub("(.+)..","c\\1",x))("stdio.h")
[1] "cstdio"

Answer 35

MS QuickBasic or QB64 ~ 33 bytes

A$=left$(A$,len(A$)-2)
A$="c"+A$

A$ is the name of the file

Answer 36

Go, 47,46

func h(s string)string{return"c"+s[:len(s)-2]}

I know I'm not winning anything with this, but I thought I might as well go for it. No pun intended

Answer 37

C++ 14, 48

[](string s){return "c"+s.substr(0,s.size()-2);}

Answer 38

><>, 22 21 bytes

Since full programs are now allowed...

i:0(?v
~}-5~/r
o;!?l<

Explanation

i:0(?v      Keep reading input until EOF
~}-5~/r     Pop the -1 from EOF, turn 'h' -> 'c' with 5- and shift to back, pop '.', reverse stack
o;!?l<      Keep outputting until the stack is empty

Answer 39

K, 7 bytes

"c",-2_

Pretty simple. Just drops 2 chars off the end and prepends a c.

Also, despite how it looks, this is actually a function:

f:"c",-2_
f"stdio.h"

Answer 40

Awk: 10 characters

$0="c"$1

Sample run:

bash-4.3$ awk -F. '$0="c"$1' <<< 'stdio.h'
cstdio

Answer 41

Tcl, 36 bytes

proc H h {set s c[regsub ..$ $h ""]}

Try it online!

Answer 42

V, 5 bytes

éc$xx

Try it online!

Hexdump:

00000000: e963 2478 78                             .c$xx

This is a full program that takes input from STDIN.

Explanation

éc     insert the character 'c'
$      go to the end of the line
xx     delete two characters

This is ic<esc>$xx in pure Vim.

Answer 43

05AB1E, 5 bytes

¨¨'cì

Try it online.
Header ε is used to for-each over the input-list to verify all test cases instead of just one.
Footer }» is to close this for-each, and print the results with new-line delimiter.

Explanation:

¨¨       # Remove the last two characters of the input
    ì    # Prepend:
  'c     #  "c"

Answer 44

Stackers (27 bytes)

«h ®h h cc ( ~ ~ 

Ungolfed Version

«h "define a table called h
®h "read STDIN to h
h "read h to the stack
cc  "add the value for 'c' to the stack
(   "put c on the bottom of the stack
~ ~ "destroy the top two values on the stack
   "print stack bottom two top

Stackers is a programming language I created myself that is meant to be based on stacks, with variables and tables thrown in

Answer 45

SNOBOL4 (CSNOBOL4), 41 bytes

	INPUT ARB . O RPOS(2)
	OUTPUT ='c' O
END

Try it online!

Answer 46

TI-89 Basic, 56 bytes

:Def a(a)=Func
:Return "c"+sub(a,1,length(a)-2
:End Func

Answer 47

Julia: 19 characters

f(s)="c"*s[1:end-2]

Sample run:

julia> f(s)="c"*s[1:end-2]
f (generic function with 1 method)

julia> print(f("stdio.h"))
cstdio

Answer 48

Perl (program) 15

s/(.*)\.h/c\1/

It converts filenames supplied on std input, and needs to be run with the p flag, so that's one more character I believe. Eg

echo stdio.h | perl -p header.pl

output:

cstdio

Note to sticklers: I just spotted that this may be invalid because challenge implies that programs are only acceptable if the language doesn't support functions. However, I'm not going to throw it all away at this stage! Ah well.

Update: Augh! And I hadn't spotted page 2 of the answers either. Please refer to @malkaroee's effectively identical answer posted 4 months ago. ... Hang on, who resurrected this thread?

Answer 49

Lua, 39 bytes

function f(n)return "c"..n:sub(1,-3)end

Answer 50

C# 6, 52 bytes

class P{string C(string f)=>"c"+f.Replace(".h","");}

C# <6, 58 bytes

class P{string C(string f){return"c"+f.Replace(".h","");}}

Answer 51

MATLAB, 19

@(c)[99,c(1:end-2)]

Fairly straight forward. Prepends 'c' to the input string less the last two letters. MATLAB automatically converts the 99 (ASCII value) to 'c' when appending to a character string.