Share Code Quickly

What is Harigami?

Harigami is a simple source code sharing service. You can share source code by an URL which is issued after submission.
You can also run your source code online such as Python, Ruby, JavaScript and so on.
For free.Use for code review.
Preferences
anonymous No title
JavaScript
window.addEventListener('keypress', handleKeyDown);

var pressed = "";
var howmany = 0;
document.querySelector('#main').innerHTML = `
<h1>${pressed}<h1>
<h2>現在${howmany}文字入力中です<h2>
<h3>右クリックでファイルにセーブできます<h3>
`
function handleKeyDown (event) {
  if(event.key !== "Enter"){
  if(event.key === "Backspace"){
    pressed = pressed.slice(0, pressed.length - 1)
  }else if (event.key === " "){
    pressed += " "
  
  }else if(/[a-zA-Z0-9]/.test(event.key)){
  pressed += event.key
  }else if(/[,.;:@!"#$%&'-^<>?+*`~=_/]/.test(event.key)){
  pressed += event.key
  }
}
  
  howmany = pressed.length
  document.querySelector('#main').innerHTML = `
<h1>${pressed}<h1>
<h2>現在${howmany}文字入力中です<h2>
`
}

function draw() {
  if (mouseButton === RIGHT && mouseIsPressed === true) {
    var typed = createWriter('typed.txt')
    typed.print(pressed);
    typed.close();
    typed.clear();
    }
}
anonymous PHPでスリーカードポーカー(簡略版)
PHP
<?php

const CARDS = [
    '2' => 2
    , '3' => 3
    , '4' => 4
    , '5' => 5
    , '6' => 6
    , '7' => 7
    , '8' => 8
    , '9' => 9
    , '10' => 10
    , 'J' => 11
    , 'Q' => 12
    , 'K' => 13
    , 'A' => 14
];

const HIGH_CARD = 'high card';
const PAIR = 'pair';
const STRAIGHT = 'straight';
const THREE_CARD = 'three card';

const HAND_RANKS = [
    'high card' => 0
    ,'pair' => 1
    ,'straight' => 2
    ,'three card' => 3
];


function showDown (string $card11, string $card12, string $card13, string $card21, string $card22, string $card23): array
{
    $cards = [$card11, $card12, $card13, $card21, $card22, $card23];
    $cardRanks = [];
    // 6枚のカードの文字列から数字部分のみを抽出し、新しい配列$cardNumbersに格納
    // その後、CARDS定数を使って数字ごとのランクに変換
    foreach ($cards as $card) {
        array_push($cardRanks, CARDS[substr($card, 1)]);
    }
    // 3つずつ各プレイヤーの手札として振り分ける
    $playerCardRanks = array_chunk($cardRanks, 3);
    // プレイヤーごとの役をユーザー定義関数checkHandsで決定。
    // $playerCardRanksを2プレイヤー分に分けてからでないと、checkHands関数で2次元配列を扱うことになってしまう上に、配列の引数2つというのも関数を定義しづらい
    $player1Hand = checkHands($playerCardRanks[0]);
    $player2Hand = checkHands($playerCardRanks[1]);
    // 勝敗を決定
    $winner = decideWinner($player1Hand, $player2Hand);
    return [$player1Hand['hand'], $player2Hand['hand'], $winner];
}

function checkHands(array $playerCardRanks): array
{
    $hand = HIGH_CARD;
    if (isThreeCard($playerCardRanks)) {
        $hand = THREE_CARD;
    } elseif (isPair($playerCardRanks)) {
        $hand = PAIR;
    } elseif (isStraight($playerCardRanks)) {
        $hand = STRAIGHT;
    }
    rsort($playerCardRanks);

    // 手札がa,2,3の場合はaを最弱にする
    // aのランク14をカードの種類の数13で割った余りは1なので、それをaのランクとする
    if ($playerCardRanks[1] === $playerCardRanks[2] + 1 && $playerCardRanks[2] === $playerCardRanks[0] % count(CARDS) + 1) {
        $playerCardRanks[0] = $playerCardRanks[0] % count(CARDS);
    }

    return [
        'hand' => $hand
        ,'handRank' => HAND_RANKS[$hand]
        ,'biggestNum' => $playerCardRanks[0]
        ,'middleNum' => $playerCardRanks[1]
        ,'smallestNum' => $playerCardRanks[2]
    ];
}

function isThreeCard(array $playerCardRanks): bool
{
    // 一つ目の値の数がカード全体の枚数に等しいとき(すなわち、全てのカードの値が同じとき)、trueを返す(ボツ案)
    // if (array_count_values($playerCardRanks)[0] === count($playerCardRanks)) {
    //     return true;

    // それぞれのプレイヤーの手札のうち、重複する種類が1種類の(すべて重複する)ときにtrueを返す
    if (count(array_unique($playerCardRanks)) === 1) {
        return true;
    } else {
        return false;
    }

    // ここは無難に、それぞれのカードの値が等しいときでも可
    // if ($playerCardRanks[0] === $playerCardRanks[1] && $playerCardRanks[1] === $playerCardRanks[2]) {
    //     return true;
    // }
}

function isPair(array $playerCardRanks): bool
{
    // if (count(array_count_values($playerCardRanks)) === 2) {
    //     return true; (ボツ案)

    // 重複する値の種類が2の時
    if (count(array_unique($playerCardRanks)) === 2) {
        return true;
    } else {
        return false;
    }
}

function isStraight(array $playerCardRanks): bool
{
    rsort($playerCardRanks);
    $biggestCard = $playerCardRanks[0];
    $middleCard = $playerCardRanks[1];
    $smallestCard = $playerCardRanks[2];
    // echo('biggestCard:' . $biggestCard);

    // 1番大きい数が2番目の数より1大きく、2番目の数が3番目の数より大きい場合
    if ($biggestCard === $middleCard + 1 && $middleCard === $smallestCard + 1) {
        return true;
    // 1番大きい数がA、2番目の数が3、1番小さい数が2の場合を想定している。
    // AのCardRank14をカードの種類の数13で割った余りは1なので、AのCardRankをそれにすり替える。(リングバッファーのアルゴリズムから着想。)
    } elseif ($middleCard === $smallestCard + 1 && $smallestCard === $biggestCard % count(CARDS) + 1) {
        return true;
    } else {
        return false;
    }
}

function decideWinner (array $player1Hand, array $player2Hand): int
{

    // 勝敗を決める要素をまとめる。それぞれの役、1番大きい数、2番目の数、1番小さい数
    $judgementElements = ['handRank', 'biggestNum', 'middleNum', 'smallestNum'];

    // それぞれの要素ごとに大小を比較していって、大小が決まった時点で結果を返す
    // いずれの要素でも決着がつかなかった場合に、0(引き分け)を返す
    foreach ($judgementElements as $judgementElement) {
        if($player1Hand[$judgementElement] > $player2Hand[$judgementElement]) {
            return 1;
        } elseif ($player2Hand[$judgementElement] > $player1Hand[$judgementElement]) {
            return 2;
        }
    }
    return 0;
}

var_dump(showDown('SK', 'D9', 'CJ', 'S10', 'H10', 'D6'));
var_dump(showDown('DK', 'S2', 'HA', 'C4', 'H5', 'S6'));
var_dump(showDown('S9', 'CJ', 'DK', 'C3', 'C3', 'H3'));
var_dump(showDown('H3', 'D4', 'C5', 'HK', 'S10', 'DK'));
var_dump(showDown('S3', 'H3', 'C3', 'D10', 'SK', 'D10'));
var_dump(showDown('C3', 'S3', 'H3', 'CK', 'SJ', 'SQ'));
var_dump(showDown('DJ', 'HK', 'S9', 'CQ', 'D9', 'S10'));
var_dump(showDown('C7', 'S5', 'H3', 'S5', 'S7', 'D3'));
var_dump(showDown('CA', 'DA', 'CK', 'D2', 'D2', 'C3'));
var_dump(showDown('HK', 'DK', 'SA', 'CA', 'SA', 'SK'));
var_dump(showDown('D4', 'D7', 'K7', 'D6', 'K4', 'C6'));
var_dump(showDown('SK', 'D9', 'CJ', 'S10', 'H10', 'D6'));
var_dump(showDown('S4', 'C4', 'S7', 'S4', 'S4', 'C7'));
var_dump(showDown('SA', 'DQ', 'DK', 'CA', 'C2', 'D3'));
var_dump(showDown('SA', 'DK', 'DQ', 'CK', 'CQ', 'DJ'));
var_dump(showDown('H2', 'D3', 'D4', 'HA', 'C2', 'S3'));
var_dump(showDown('S2', 'S3', 'S4', 'C2', 'C3', 'D4'));
var_dump(showDown('S2', 'S2', 'S2', 'DA', 'HA', 'CA'));
var_dump(showDown('CK', 'CK', 'SK', 'SA', 'HA', 'DA'));
var_dump(showDown('D2', 'C2', 'S2', 'C3', 'H3', 'S3'));

anonymous No title
C++
#include <iostream>
using namespace std;

int main(void){

    string d, e, f;
    cin >> d >> e >> f;
    cout << d << "と" << e << "と" << f << endl;
}
anonymous set_logger and kill_logger
Python
#------------------------------------------------------------------------------------------
def set_logger():
    #======================================================================================
    # set logger
    #--------------------------------------------------------------------------------------
    # ロガーにファイルハンドラ・コンソールハンドラをセットします
    # プログラムを終了する場合は、ロガーの終了処理(関数:kill_logger)を挟んでください
    # INPUT:なし
    # OUTPUT:なし
    #======================================================================================

    #ロガーを定義
    logger = logging.getLogger(__name__)
    logger.setLevel(DEBUG)

    #出力フォーマット定義
    #20220212 12:00:00 CRITICAL >> Excution has failed.
    formatter = logging.Formatter('[%(asctime)s] %(levelname)s >> %(message)s')

    #コンソール出力用ハンドラ定義
    s_handler = logging.StreamHandler()
    s_handler.setLevel(DEBUG)
    s_handler.setFormatter(formatter)

    #ログファイル出力用ハンドラ定義
    f_handler = logging.FileHandler('.\\ExcelKeyReadLog.log','a+')
    f_handler.setLevel(INFO)
    f_handler.setFormatter(formatter)

    #ハンドラをロガーに登録
    logger.addHandler(s_handler)
    logger.addHandler(f_handler)

    logger.debug('set the logger has completed.')

    #デバッグ:ハンドラ一覧を表示
    print([logging.getLogger(name) for name in logging.root.manager.loggerDict])

    return
#------------------------------------------------------------------------------------------

def kill_logger():

    #======================================================================================
    # kill logger
    #--------------------------------------------------------------------------------------
    # set loggerで起動したロガーを終了します
    # INPUT:なし
    # OUTPUT:なし
    #======================================================================================

    #ロガーを削除
    del logging.Logger.manager.loggerDict[__name__]

    #デバッグ:ハンドラ一覧を表示
    print([logging.getLogger(name) for name in logging.root.manager.loggerDict])
   
    return
#------------------------------------------------------------------------------------------
anonymous No title
Python
import pygame.mixer
import schedule
import time
import tkinter as tk  # Tkinterをインポート

fonts = ("", 20)  # フォントの書式とサイズを指定


# 音再生処理
def Sound():
    pygame.mixer.init()  # 初期化
    pygame.mixer.music.load('alerm1.mp3')  # 読み込み
    pygame.mixer.music.play(-1)  # ループ再生(引数を1にすると1回のみ再生)
    input()
    pygame.mixer.music.stop()  # 終了


def Alarm():
    print("時間です")
    print("\007")  # ビープ音
    Sound()
    exit()  # これがないと無限ループになるので注意


class Calculator(tk.Frame):
    # ウィンドウの作成
    def __init__(self, master=None):
        tk.Frame.__init__(self, master)
        self.master.geometry('1024x768')
        self.master.title('アラーム時刻設定')  # ウィンドウタイトルを指定
        self.entry = tk.Entry(self.master, justify='right', font=fonts)  # テキストボックスを作成
        self.creat_widgets()

    def input(self, num):
        def n():
            self.entry.insert(tk.END, num)
            return n

    def schedule_check(self):  # scheduleモジュールにて定期的にタスク状態を確認
        schedule.run_pending()
        self.after(1, self.schedule_check)

    def btn_click(self):
        self.ala = self.entry.get()
        target = ':'
        idx = self.ala.find(target)
        r = self.ala[idx + 1:]
        s = self.ala[:idx]
        setal = f"{s.zfill(2)}:{r.zfill(2)}"
        schedule.every().day.at(setal).do(Alarm)
        print(f"アラーム時刻・・・{setal}")
        self.schedule_check()

    # 1文字削除
    def clear_one(self):
        text = self.entry.get()
        self.entry.delete(0, tk.END)
        self.entry.insert(0, text[:-1])

    def creat_widgets(self):
        Buttons = [
            ['1', '2', '3', '4', '5'],
            ['6', '7', '8', '9', '0']]

        # 各ボタンを配置
        for i, ro in enumerate(Buttons):
            for j, co in enumerate(ro):
                tk.Button(self.master, font=fonts, text=co, width=7, height=2, command=self.input(co)).grid(row=i + 2,
                                                                                                            column=j)

        # テキストボックスを配置
        self.entry.grid(row=0, column=1, ipady=10, columnspan=3, sticky='nsew')

        # 各ボタンの処理
        tk.Button(self.master, text=':', font=fonts, width=1, height=2, command=self.input(':')).grid(row=9, column=0)
        tk.Button(self.master, text='←', font=fonts, width=1, height=2, command=lambda: self.clear_one()).grid(row=9,
                                                                                                           column=1)
        tk.Button(self.master, text='O K', font=fonts, width=20, height=2, command=lambda: self.btn_click()).grid(row=10,
                                                                                                              column=0,
                                                                                                              columnspan=10)


# 実行
calc = Calculator(tk.Tk())
calc.mainloop()
anonymous No title
Ruby
#!/usr/bin/env ruby

# This file loads Spring without using Bundler, in order to be fast.
# It gets overwritten when you run the `spring binstub` command.

unless defined?(Spring)
  require 'rubygems'
  require 'bundler'

  lockfile = Bundler::LockfileParser.new(Bundler.default_lockfile.read)
  spring = lockfile.specs.detect { |spec| spec.name == 'spring' }
  if spring
    Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
    gem 'spring', spring.version
    require 'spring/binstub'
  end
end
anonymous No title
Python
"><xmp>
フェアリーテイル56~ kadai1
C
#include <stdio.h>
#define NUMBER 5
#define FAILED -1
int search(int vc[], int key, int no){
    int i = 0;
    vc[no] = key;
    while(1){
        if(vc[i]==key){
            break;
        }
        i++;
    }
    return(i==no ? FAILED : i);
}

int main(void){
    int i,key,index;
    int vx[NUMBER+1];
    for (int i=0; i<NUMBER; i++) {
        printf("vx[%d]: ", i);
        scanf("%d", &vx[i]);
    }
    printf("探す値:");
    scanf("%d", &key);

    index = search(vx, key, NUMBER);
    
    if(index==FAILED){
        printf("探索失敗");
    }
    else {
        printf("%d is in %d\n", key, index);
    }
    return 0;
}
anonymous No title
C
#include <stdio.h>

int a[11] = {6, 7, 11, 12, 14, 18, 19, 21, 24, 28, 37};
int main(void){
    int key = 11;
    int l = -1;
    int r = sizeof(a)/sizeof(int);
    while (r-l > 1) {
        int m = l + (r - l)/2;
        if (a[m] > key) {
            r = m;
        }
        else {
            l = m;
        }
    }
    printf("%d", r);
    return 0;
}
ごるだっく 3node_origin
Python
# (1)拡張モジュールのインポート
import numpy as np                  # 配列を扱う数値計算ライブラリNumPy
import matplotlib.pyplot as plt     # グラフ描画ライブラリmatplotlib
import japanize_matplotlib          # matplotlibの日本語化

# (2)時間変数tの導入
T = 700                  # 変数tの範囲 0≦t<T(日)(250,150,150,700と値を変えてシミュレーションを行う)
n = 10*T                 # 変数tの範囲をn等分   n=T/h=T/0.1=10*T (T=250のときはn=2500)
h = 0.1                  # 等差数列の公差:0.1 固定
t = np.arange(0,T,h)     # 0から公差dtでTを超えない範囲で等差数列を生成 t[0],...,t[n-1] 要素数n個

# (3)SIRモデル
# 3-1パラメータ
N1 = 10000000             # モデルエリアの人口(人)(東京都1400万人に匹敵するエリアを想定) N=S+I+R=一定
N2 = 100000
N3 = 1000000
m1 = 10
m2 = 10                  # 1日1人あたり接触する人数(人)(10,50,100,5と値を変えてシミュレーションを行う)
m3 = 10
p = 0.02               #5接触ごとに感染が生じる1日あたりの確率
d = 14                   # 感染者の回復平均日数(日)
nu1 = 0                 #ワクチン接種率
nu2 = 0
nu3 = 0
alpha1 = 0.01               #重症化率
alpha2 = 0.01
alpha3 = 0.01
beta1 = m1*p / N1           # 接触あたりの感染率
beta2 = m2*p / N2           # 接触あたりの感染率
beta3 = m3*p / N3           # 接触あたりの感染率
beta12=(beta1+beta2)/100
beta23=(beta2+beta3)/100
beta31=(beta3+beta1)/100

c12=1
c23=1
c31=1

gamma = 1/d              # 回復率(隔離率)
# 3-2初期値
Im1_0 = 100                # 初期感染者数(人)100人
Is1_0=0
R1_0 = 0                  # 初期回復者数(人)0人
S1_0 = N1 - Im1_0 - Is1_0 - R1_0      # 初期未感染者数(人)S_0 = N - Im_0- Is_0 - R_0

Im2_0 = 0                # 初期感染者数(人)100人
Is2_0=0
R2_0 = 0                  # 初期回復者数(人)0人
S2_0 = N2 - Im2_0 - Is2_0 - R2_0      # 初期未感染者数(人)S_0 = N - Im_0- Is_0 - R_0

Im3_0 = 0                # 初期感染者数(人)100人
Is3_0=0
R3_0 = 0                  # 初期回復者数(人)0人
S3_0 = N3 - Im3_0 - Is3_0 - R3_0      # 初期未感染者数(人)S_0 = N - Im_0- Is_0 - R_0

# 3-3微分方程式
dS1dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t : - beta1*S1*Im1 - nu1*S1-c12*beta12* S1*Im2-c31*beta31* S1*Im3             # dSdt ≡ dS/dt  dSdt(S, I, R, t)
dIm1dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t: beta1*S1*Im1 - alpha*Im1 - gamma*Im1+c12*beta12* S1*Im2+c31*beta31* S1*Im3       # dIdt ≡ dI/dt  dIdt(S, I, R, t)
dIs1dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t : alpha*Im1-gamma*Is1
dR1dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t: gamma*(Im1+Is1)+nu1*S1                  # dRdt ≡ dR/dt  dRdt(S ,I ,R, t)

dS2dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t : - beta2*S2*Im2 - nu2*S2-c12*beta12* S2*Im1-c23*beta23* S2*Im3             # dSdt ≡ dS/dt  dSdt(S, I, R, t)
dIm2dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t: beta2*S2*Im2 - alpha*Im2 - gamma*Im2+c12*beta12* S2*Im1+c23*beta23* S2*Im3       # dIdt ≡ dI/dt  dIdt(S, I, R, t)
dIs2dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t : alpha*Im2-gamma*Is2
dR2dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t: gamma*(Im2+Is2)+nu2*S2                  # dRdt ≡ dR/dt  dRdt(S ,I ,R, t)

dS3dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t : - beta3*S3*Im3 - nu3*S3 - c31*beta31* S3*Im1-c23*beta23* S3*Im2             # dSdt ≡ dS/dt  dSdt(S, I, R, t)
dIm3dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t: beta3*S3*Im3 - alpha*Im3 - gamma*Im3+c31*beta31* S3*Im1+c23*beta23* S3*Im2       # dIdt ≡ dI/dt  dIdt(S, I, R, t)
dIs3dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t : alpha*Im3-gamma*Is3
dR3dt = lambda S1,S2,S3, Im1,Im2,Im3,Is1,Is2,Is3, R1,R2,R3,alpha,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3,c12,c23,c31, t: gamma*(Im3+Is3)+nu3*S3                  # dRdt ≡ dR/dt  dRdt(S ,I ,R, t)

# 3-4数値積分変数S,I,Rをリストとして生成
S1 = np.empty(n)          # S[0],...,S[n-1] 要素数n個
Im1 = np.empty(n)          # Im[0],...,Im[n-1] 要素数n個
Is1=np.empty(n)            # Is[0],...,Is[n-1] 要素数n個
R1 = np.empty(n)          # R[0],...,R[n-1] 要素数n個

S2 = np.empty(n)          # S[0],...,S[n-1] 要素数n個
Im2 = np.empty(n)          # Im[0],...,Im[n-1] 要素数n個
Is2=np.empty(n)            # Is[0],...,Is[n-1] 要素数n個
R2 = np.empty(n)          # R[0],...,R[n-1] 要素数n個

S3  = np.empty(n)          # S[0],...,S[n-1] 要素数n個
Im3 = np.empty(n)          # Im[0],...,Im[n-1] 要素数n個
Is3 = np.empty(n)            # Is[0],...,Is[n-1] 要素数n個
R3  = np.empty(n)          # R[0],...,R[n-1] 要素数n個

sum1=np.empty(n)
sum2=np.empty(n)
sum3=np.empty(n)
# 3-5初期値代入
S1[0] = S1_0
Im1[0] = Im1_0
Is1[0]=Is1_0
R1[0] = R1_0

S2[0] = S2_0
Im2[0] = Im2_0
Is2[0]=Is2_0
R2[0] = R2_0

S3[0] = S3_0
Im3[0] = Im3_0
Is3[0]=Is3_0
R3[0] = R3_0
sum1[0]=0
sum2[0]=0
sum3[0]=0

# (4)数値積分 4次ルンゲ-クッタ法 4th-Order Runge–Kutta Methods
for j in range(n-1):     # j=0,...,n-2 -> S[j]=S[0],...,S[n-1](I[j],R[j]も同じ) 要素数n個

  kS11 = h * dS1dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIm11 = h * dIm1dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIs11 = h * dIs1dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kR11 = h * dR1dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kS21 = h * dS2dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIm21 = h * dIm2dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIs21 = h * dIs2dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kR21 = h * dR2dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kS31 = h * dS3dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIm31 = h * dIm3dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIs31 = h * dIs3dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kR31 = h * dR3dt( S1[j],S2[j],S3[j] ,Im1[j],Im2[j],Im3[j],Is1[j],Is2[j],Is3[j],R1[j] ,R2[j],R3[j],alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])

  kS12 = h * dS1dt(  S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIm12 =h * dIm1dt(S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIs12 =h * dIs1dt(S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kR12 = h * dR1dt(S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kS22 = h * dS2dt(  S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIm22 =h * dIm2dt(S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIs22 =h * dIs2dt(S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kR22 = h * dR2dt(S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j])
  kS32 = h * dS3dt(  S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm11/2,Im2[j]+kIm21/2,Im3[j]+kIm31/2,Is1[j]+kIs11/2,Is2[j]+kIs21/2,Is3[j]+kIs31/2,R1[j]+kR11/2 ,R2[j]+kR21/2,R3[j]+kR31/2,alpha1,beta1,beta2,beta3,beta12,beta23,beta31,nu1,nu2,nu3 ,c12,c23,c31,t[j] )
  kIm32 =h * dIm3dt(S1[j]+kS11/2,S2[j]+kS21/2,S3[j]+kS31/2 ,Im1[j]+kIm1