常連

### 前提・実現したいこと
[Hckerrankの問題](https://www.hackerrank.com/contests/01022343222/challenges/1-247/problem)
この問題がセグメンテーションエラーとWAが出てしまいます。
1<N<30は制約の一つです。


### 発生している問題・エラーメッセージ
どのような入力でエラー・WAになってしまうか教えていただいきたいです

セグメンテーションエラー,Wrong Eroor


### 該当のソースコード(不正解)

```c++
#include <iostream>
using namespace std;

int main()
{
    int N, C, D;
    cin >> N >> C >> D;

    int A[50], B[50];

    for (int i = 0; i < N; i++)
    {
        cin >> A[i];
    }
    for (int i = 0; i < N; i++)
    {
        cin >> B[i];
    }

    int summp = 0; //mpの和
    int dif = 0;　//りんごの差
    int S = 0;

    if (C >= (5 * D)) //条件に当てはまるならすべてDの魔法
    {
        S = 1;
    }

    for (int i = 0; i < N; i++)
    {

        if (A[i] != B[i])
        {
            dif = B[i] - A[i];

            if (dif < 0) 
            {
                dif = -dif;
            }

            if (S == 1)
            {
                summp += dif * D;
            }

            if (S == 0)
            {
                if (dif % 5 != 0)
                {
                    summp += dif * D;
                }

                if (dif % 5 == 0)
                {
                    summp += dif / 5 * C;
                }
            }
        }
    }

    cout << summp;
}
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）
gcc(g++コマンド)
ここにより詳細な情報を記載してください。

#解決しました。
- Cの魔法のコストがCkではなくCということに気づきませんでした。
- セグメンテーションエラーに関しては使われていない配列があったからだと思います。



```c++
#include <iostream>
using namespace std;

int main()
{
    int N, C, D;
    cin >> N >> C >> D;

    int A[N], B[N];

    for (int i = 0; i < N; i++)
    {
        cin >> A[i];
    }
    for (int i = 0; i < N; i++)
    {
        cin >> B[i];
    }

    int summp = 0;
    int dif = 0;

    for (int i = 0; i < N; i++)
    {

        if (A[i] != B[i])
        {
            dif = B[i] - A[i];

            if (dif < 0)
            {
                dif = -dif;
            }

            if (dif % 5 != 0)
            {
                summp += dif * D;
            }

            if (dif % 5 == 0)
            {
                if (C <= dif * D)
                {
                    summp += C;
                }
                else
                {
                    summp += (D * dif);
                }
            }
        }
    }

    cout << summp << endl;

    return 0;
}

```
**ご協力いただいた皆様ありがとうございました。**

どのような入力でエラーになるのかを教えていただいきたいです。

引数nから値を求める簡単なプログラムを作成しましたが、
以下のプログラムでセグメンテーション違反がでます。
大きな数字の用いた時にコアダンプが生じます。
lldbを用いてデバッグしたところ、
func関数の返り値のところでbreakしていました。
ここまではわかったのですが、ここから先の解決方法がわかりません。
ご回答よろしくおねがいいたします。

```c++
#define ffor(i,a,b) for (int i=(a);i<(b);i++)
#define rfor(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define rep(i,n) for (int i=0;i<(n);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cmath>
#include<string>
#include<stack>
#include<queue>
#define SIZE 10000001
#define MOD 1000000007
#define INF 100000000
using namespace std;

int memo[SIZE];
int s = 10007;
int func(int n){
	if(n == 3) return 1;
	if(n <= 2) return 0;
	if(memo[n] != 0) return memo[n];

	return memo[n] = (func(n-1)+func(n-2)+func(n-3))%s;
}

int main(){
	int n;
	cin >> n;

	cout << func(n) << endl;

	return 0;
}

```


追記
記入不足があり申し訳有りません。
SIZE以上の入力が出た時にコアダンプが出るという点は承知しております。
入力値が10^4程度だとエラーが出ないのですが、10^6くらいの値からエラーが出ます。

セグメンテーションエラーが消えない

# 状況と質問

Cで書かれたあるソースコード（**念のため一番下に載せておきます**）をコピペして動かしたいのですが、セグフォのエラーが出てしまいました。そこで最低限のものを書いて実験したところ、ループの途中でセグフォが出ていることがわかりました。

どうしてループの途中で、しかも決まった回数のときにsegmentation faultになるのでしょうか？　またそれを解決する方法はありますか？

初歩的な質問かもしれないことは承知ですが、調べるとっかかりになるワードだけでも構いませんので、ご回答いただければ助かります。

# コード

```C
// test2.h

#include <stdio.h>

struct udmabuf{
    char name[128];
    unsigned char * buf;
};
```

```C
// test1.c

#include <stdio.h>
#include "test2.h"

int main(){
    struct udmabuf intake_buf;
    float a[32 * 32]; 
    int i, j; // 行列の添字
    int m, n; // 行列のサイズ
    m = n = 32;
    for (i = 0; i < m*n; i++){ // 行列を初期化
        a[i] = i / 2.0; 
    }

    int count = 0;
    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i * n + j] = a[i * n + j];
            printf("%d\n", count); // 420までで止まる。なぜ？？
            count = count + 1;
        }
    }

    return 0;
}

```

```bash
# 実行結果
$ gcc test1.c && ./a.out
1
2
3
...
418
419
420
Segmentation fault: 11
```

# 元にしている実際に動かしたいコード

```c
// dma_simple.h

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/mman.h>

#define DMA_INTAKE_DMACR   (0x0000)
#define DMA_INTAKE_DMASR   (0x0004)
#define DMA_INTAKE_SA      (0x0018)
#define DMA_INTAKE_LENGTH  (0x0028)

#define DMA_OUTLET_DMACR   (0x0030)
#define DMA_OUTLET_DMASR   (0x0034)
#define DMA_OUTLET_DA      (0x0048)
#define DMA_OUTLET_LENGTH  (0x0058)

#define DMA_CR_RS      (1u<<0)
#define DMA_CR_RESET   (1u<<2)

#define DMA_SR_HALTED  (1u<<0)
#define DMA_SR_IDLE    (1u<<1)
#define DMA_SR_IOC_Irq (1u<<12)
#define DMA_SR_ERR_Irq (1u<<14)


static inline uint32_t regs_read32 (void* addr){
    volatile uint32_t* regs_addr = (uint32_t*)(addr);
    return *regs_addr;
}

static inline void regs_write32 (void* addr, uint32_t data){
    volatile uint32_t* regs_addr = (uint32_t*)(addr);
    * regs_addr = data;
}

static inline void dma_reset (void* regs){
    regs_write32(regs+DMA_INTAKE_DMACR, DMA_CR_RESET);
    while(regs_read32(regs+DMA_INTAKE_DMACR) & DMA_CR_RESET); // この構文謎い
    regs_write32(regs+DMA_OUTLET_DMACR, DMA_CR_RESET);
    while(regs_read32(regs+DMA_OUTLET_DMACR) & DMA_CR_RESET);
}

static inline void dma_setup (
        void* regs,
        unsigned long src_addr,
        unsigned long dst_addr
    ){
    regs_write32(regs + DMA_OUTLET_DMACR, DMA_CR_RS);
    regs_write32(regs + DMA_OUTLET_DA   , dst_addr);
    regs_write32(regs + DMA_INTAKE_DMACR, DMA_CR_RS);
    regs_write32(regs + DMA_INTAKE_SA   , src_addr);
}

static inline void dma_intake_start (void* regs, unsigned int xfer_size){
    regs_write32(regs + DMA_INTAKE_LENGTH, xfer_size);
}

static inline void dma_outlet_start (void* regs, unsigned int xfer_size){
    regs_write32(regs + DMA_OUTLET_LENGTH, xfer_size);
}

static inline void dma_wait_irq (void* regs){
    while (~regs_read32(regs + DMA_INTAKE_DMASR) & DMA_SR_IOC_Irq);
    while (~regs_read32(regs + DMA_OUTLET_DMASR) & DMA_SR_IOC_Irq);
}

static inline void dma_clear_status (void* regs){
    regs_write32(regs + DMA_INTAKE_DMASR, DMA_SR_IOC_Irq | DMA_SR_ERR_Irq);
    regs_write32(regs + DMA_OUTLET_DMASR, DMA_SR_IOC_Irq | DMA_SR_ERR_Irq);
}

struct udmabuf {
    char           name[128];
    int            file;
    unsigned char* buf;
    unsigned int   buf_size;
    unsigned long  phys_addr;
    unsigned long  debug_vma;
    unsigned long  sync_mode;
};

int udmabuf_open  (struct udmabuf* udmabuf, const char* name);
int udmabuf_close (struct udmabuf* udmabuf);
```

```c
// dma_simple.c

#include "dma_simple.h"

int udmabuf_open (struct udmabuf* udmabuf, const char* name){
    char file_name[1024];
    int fd;
    unsigned char attr[1024];

    strcpy(udmabuf -> name, name);
    udmabuf -> file = -1;

    // phys_addr
    sprintf(file_name, "/sys/class/u-dma-buf/%s/phys_addr", name);
    if (
            (fd = open(file_name, O_RDONLY)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }
    read(fd, (void*)attr, 1024);
    sscanf(attr, "%x", &udmabuf->phys_addr);
    close(fd);

    // size
    sprintf(file_name, "/sys/class/u-dma-buf/%s/size", name);
    if (
            (fd = open(file_name, O_RDONLY)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }
    read(fd, (void *)attr, 1024);
    sscanf(attr, "%x", &udmabuf -> buf_size);
    close(fd);

    sprintf(file_name, "/dev/%s", name);
    if (
            (udmabuf -> file = open(file_name, O_RDWR | O_SYNC)) == -1
        ){
        printf("Can not open %s\n", file_name);
        return (-1);
    }

    udmabuf -> buf = mmap(NULL, udmabuf -> buf_size, PROT_READ|PROT_WRITE, MAP_SHARED, udmabuf -> file, 0);
    udmabuf -> debug_vma = 0;
    udmabuf -> sync_mode = 1;

    return 0;
}

int udmabuf_close(struct udmabuf* udmabuf){
    if (udmabuf -> file < 0) return -1;

    close(udmabuf -> file);
    udmabuf -> file = -1;
    return 0;
}
```

```c
// matrix.c

#include "dma_simple.h"

void main(){
    int uio1_fd = open("/dev/uio4", O_RDWR);
    void *hls_regs = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uio1_fd, 0);

    int uio2_fd = open("/dev/uio5", O_RDWR);
    void *dma_regs = mmap(NULL, 0x1000, PROT_READ|PROT_WRITE, MAP_SHARED, uio2_fd, 0);

    struct udmabuf intake_buf;
    struct udmabuf outlet_buf;
    if (udmabuf_open(&intake_buf, "udmabuf0") == -1) exit (1);
    if (udmabuf_open(&outlet_buf, "udmabuf1") == -1) exit (1);

    dma_reset(dma_regs);
    regs_write32(hls_regs, 0x81);

    float a[32*32];
    float b[32*32];
    float c[32*32];
    float cref[32*32];
    int i, j, t;
    int m, n, k;
    m = n = k = 32;

    for (i = 0; i < m*n; i++){
        a[i] = (float) i/2.0;
        b[i] = (float) i/3.0;
        c[i] = (float) 0;
    }

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i*n + j] = a[i*n + j];
        }
    }
    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            ((float *)(intake_buf.buf))[i*n + j + m*m] = b[i*n + j];
        }
    }

    dma_setup(dma_regs, intake_buf.phys_addr, outlet_buf.phys_addr);

    dma_outlet_start(dma_regs, m*m*4);
    dma_intake_start(dma_regs, m*m*2*4);

    dma_wait_irq(dma_regs);
    dma_clear_status(dma_regs);

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            c[i*n + j] = ((float*)(outlet_buf.buf))[i*n + j];
        }
    }

    for (i = 0; i < m; i++){
        for (j = 0; j < n; j++){
            float sum = 0;
            for (t = 0; t < k; t++){
                sum += a[i*k + t] * b[t*n + j];
            }
            cref[i*n + j] = sum;
        }
    }

    int cnt_ok = 0;
    int cnt_ng = 0;
    for (i = 0; i < m*m; i++){
        if (c[i] == cref[i]){
            cnt_ok++;
        } else {
            printf("NG: hw %f, sw %f\n", c[i], cref[i]);
            cnt_ng++;
        }
    }
    printf("OK: %d, NG: %d, Total: %d\n", cnt_ok, cnt_ng, m*m);
    udmabuf_close(&outlet_buf);
    udmabuf_close(&intake_buf);
    close(uio2_fd);
    close(uio1_fd);
}
```

【C言語】ループの途中でSegmentation faultが出る

### リスト構造への追加
画面から場所とデータを入力し、リスト構造にデータを追加するプログラムを作りました。
しかしコンパイルは通ったのですが実行するとセグメンテーション違反と表示されてしまいます。
どこがおかしいのでしょうか。教えて欲しいです。
よろしくおねがいします。

### 該当のソースコード

```c言語
#include <stdio.h>
#include <stdlib.h>

#define FILENAME "data_2105.txt"

struct LIST {
  int score;
  struct LIST *next;
};
typedef struct LIST LIST;


// リストを表示する関数
void  show_list(LIST *lh){
  LIST *p;
  p=lh;
  while(p != NULL){
    printf(" -> %d" , p->score);
      p=p->next;
} 
  printf("\n");
}


int main( void ) {
  int dat;
  int place,data,i;
  LIST *listhead = NULL;  // リストの先頭へのポインタ
  LIST *listtail = NULL;  // リストの末尾へのポインタ
  LIST *p,*q,*r,*temp;                // 一時ポインタ
  FILE *fp;               // ファイルポインタ

  // ファイルを開く
  if ( ( fp = fopen( FILENAME, "r" ) ) == NULL ) {
    fprintf( stderr,"ファイルが開けません\n" );
    exit( 1 );
  }


  // データを読み込み、構造体リストに格納する
  while( fscanf( fp, "%d",  &dat) != EOF ) {

    // 構造体を1個準備し，データを入力する
    p = ( LIST * )malloc( sizeof( LIST ) );
    p->score = dat;
    p->next = NULL;
    
    // 1個目のデータのときはリストの先頭に接続する，同時に末尾も登録する
    if ( listhead == NULL ) {
      listhead=p;
      listtail=p;
      
    }
    // 2個目以降のデータのときはリストの末尾に接続する
    else {
      listtail->next=p;
      listtail=p;
      
    }
  }

  // リストに格納されたデータを表示する
  show_list( listhead );

  //リストへの追加
do{
//データの読み込み
  printf("挿入場所(-1で終了) ; ");
  scanf("%d" , &place);
  printf("データ ; ");
  scanf("%d" , &data);
   r = ( LIST * )malloc( sizeof( LIST ) );
   r->score=data;
   r->next=NULL;
//場所が最初の場合
  if(place==0){
    temp=listhead;
    listhead=r;
    listhead->next=temp;
 show_list( listhead );
  }else{
//場所が最初以外の場合
for(i=0;i<=place-1;i++){
  if(i==0){
 temp=listhead;
 temp=r;
 listtail=r;
  }
   temp= temp->next;
}
 r->next=temp->next;
 temp->next=r;
show_list( listhead );
}
  
 }while(place !=-1);
  // リストのメモリを開放する
  while(p != NULL){
    q=p->next;
    free(p);
    p=q;
}
  while(r !=NULL){
    q=r->next;
    free(r);
    r=q;
}

  // ファイルを閉じる
  fclose( fp );
  return 0;
}
```

c言語　リスト構造への追加

###　正しく値が表示されるようにしたい

c言語で正の整数を入力し小さい順に並べるというリスト構造を再帰を用いて作りたいのですが以下の問題が発生してしまいます。
 10行目の (*q)->data = a;　がうまく作動していないのことがわかったのですがうまく行きません。
原因と解決法を教えてほしいです。

### 発生している問題・エラーメッセージ

```
正の値の入力しても何も表示されない。
負の値を入力するとセグメンテーションエラーが発生する。
(例)
0以上のデータを入力して下さい(負の値で終了) -->4

0以上のデータを入力して下さい(負の値で終了) -->-1
セグメンテーション違反です


```

### 該当のソースコード

```c
#include<stdio.h>
#include<stdlib.h>

struct cell{
  double data;
  struct cell *next;
};

void add_list(struct cell **q, double a){
  if((*q)->next == NULL){
    (*q)->data = a;
  }
  if((*q)->data < a){
    add_list(&(*q)->next,a);
  }
  else{
    (*q)->data = a;
  }
}

void show_list(struct cell **q ){
  if((*q)->next == NULL){
    printf("\n");
  }
  else{
    printf("-> %lf" , (*q)->data);
    show_list(&(*q)->next);
  }
}

void free_list(struct cell *q ){
  if(q->next != NULL){
    free_list(q->next);
  }
  free(q);
}


int main(void){
 double data;
 struct cell *p;
 (*p).next = NULL;

  while(1){
    printf("0以上のデータを入力して下さい(負の値で終了) -->");
    scanf("%lf" , &data);
    if(data < 0){
      free_list(p);
    }
    else{
      add_list(&p,data);
      show_list(&p);
    } 

  }

  return 0;
}

```

### 試したこと

gdbコマンドによる値の確認

c言語　再帰を用いたリスト構造でのエラー

c言語でプログラムを作っているのですが、構造体の中のポインタを参照するとセグメンテーション違反と出ました。

調べてみたらこんな記事があって解決方法も載ってました。
http://oshiete.goo.ne.jp/qa/3144134.html
この中の4の回答者様と同じようにたぶん実態がないんだと思います。

そこでいろいろ試してみてこういうものを作ったのですが、こうするとprintfで変な値を指しています。たぶん環境によって変わると思いますが、自分の場合は./a.outを指していました。

この挙動はなぜ起こるのですか？また、このように別の関数で構造体を宣言して、その後、別の関数からポインタで参照する方法を教えてください。

お願いします。

```c
#define DEBUG

 #include<stdio.h>

 #include<stdlib.h>



struct Sort{

    int no;

    char *name;

    

    char *avg;

    //char *maximax;

    char *saiaku_saidai;

    

    char *alias;

};
void sortinit(struct Sort *);

int main(void){
struct Sort *arr;
void *fes;

sortinit(arr);
//struct Sort *aa=(struct Sort *)fes;

    printf("%s",arr->name);

    return 0;  

}

 void sortinit(struct Sort *in){
   struct Sort sortArr[]={

            {

                1,"バブルソート","nasi","n^2","基本交換法"

            },{

                2,"選択ソート","n^2","n^2","基本三法"

            },{

                3,"挿入ソート","n+d","n^2","基本三法"

            },{

                4,"シェルソート","nasi","nlog^2n",""

            },{

                5,"マージソート","nlogn","nlogn",""

            },{

                6,"ヒープソート","nlogn","nlogn",""

            },{

                7,"クイックソート","nlogn","n^2",""

            },{

                8,"ただの(偏った)二分木","n+1/2","n","線形探索法"

            },{

                9,"完全二分木","","",""

            },{

                10,"2分探索法","","",""

            }

    };
in=sortArr;
//struct Sort *in2=(struct Sort *)in;

}
```

C言語 構造体とポインタでセグメンテーション違反

C言語で2分木を使った昇順ソートアルゴリズムを作成しています。
小さい順に表示しようとするとセグメンテーション違反が起こってしまいます。原因がわからないので教えていただきたいです。

### ソース

```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


struct tree {
    int value;
    struct tree *left;
    struct tree *right;
};

// ノードを追加
int append(int input, struct tree *current_node) {
    if (input < current_node->value) {
        if (current_node->left != NULL) {
            append(input, current_node->left);
        } else {
            struct tree new = {input, NULL, NULL};
            current_node->left = &new;
        }
    
    } else {
        if (current_node->right != NULL) {
            append(input, current_node->right);
        } else {
            struct tree new = {input, NULL, NULL};
            current_node->right = &new;
        }
    }
}


// 小さい順に表示
void sort(struct tree *current_node) {
    if (current_node->left != NULL) {
        sort(current_node->left);
    }
    printf("%d, ", current_node->value);
    if (current_node->right != NULL) {
        sort(current_node->right);
    }
}



int main() {
    int sequence[] = {2, 4, 6, 1, 8, 2, 10, 0};
    int n = sizeof(sequence) / sizeof(int);
    struct tree root = {
        sequence[0],
        NULL,
        NULL
    };
    for (int i = 1; i < n; i++) {
        append(sequence[i], &root);
    }
    sort(&root);
    printf("\n");
}
```

### 発生している問題・エラーメッセージ
sort()関数のところでセグメンテーション違反が起こっています。


### 試したこと
gdbでステップ実行をしてみたのですが、sort()にはいった段階でそれぞれのノードのvalueの値が-129660088のようにおかしくなっていました。


### 環境
WSL2, Ubuntu20.04LTS, gcc version9.3.0,

C言語での2分木ソートアルゴリズムでセグメンテーション違反が取り除けない

###セグメンテーション違反を直したいです

c言語でスタックを作ったのですがpopを実行時にセグメンテーション違反が発生してしまいます。
popの関数ではスタックから値を一つ消したいのですが、スタックの中身がひとつもないときにpopを実行するとプログラムが終了するようにしたいです。
またpopによって中身が0個になった場合はそのことを表示したいです。
よろしくおねがいします。

### 該当のソースコード

```c言語
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void push( char );
char pop();
void free_stack();
void print_stack();
struct cell{
  char c;
  struct cell *next;
};
typedef struct cell cell;

cell *p;
cell *listhead;

//pushする関数
void push(char s/*pushする文字*/){
 p=(cell*)malloc(sizeof( cell ) );
    p->c = s;
    p->next = listhead;
    listhead = p;
}

//popする関数
char pop(){
  cell *tmp = NULL; 
  if(listhead == NULL ){
    printf("スタックは空です\n");
    free_stack();  
  }
  else{
    tmp=p->next;
    listhead = tmp;
    free(p);
  }
 print_stack();
      return tmp->c;
}

//end後スタックのメモリを開放する関数
void free_stack(){
  cell *q;
 while(p != NULL){
    q=p->next;
    free(p);
    p=q;
  }
 printf("プログラムを終了します\n");
}

//スタックの内容を表示する関数
void print_stack(){
  while(p != NULL){
 printf(" -> %c" , p->c);
      p=p->next;
} 
  printf("\n");
   
}

int main(void){
  char in[100];//スタック
  int n=0;//保存されているデータ数
  
  do{
    printf("pushする文字かpop/endを入力して下さい --> ");
    scanf("%s" , &in[n]); 
    //endの入力
    if(strcmp(&in[n],"end") == 0){
      printf("スタックを空にしました\n");
      free_stack();
}
    //popの処理
    else if (strcmp(&in[n],"pop") == 0){
      printf("popされた文字は %c です\n" , pop());
      if(n>0){
      n--;
      }
}
    //popやendでない時の処理
    else if(strlen(&in[n]) != 1){
      printf("不正な入力です\n");
      free_stack();
      break;
}
    //適切な入力の処理
    else{
      push(in[n]);
      print_stack();
      n++;
}

  }while(strcmp(&in[n],"end") != 0);

   
  return 0;
}

```